void loadmod(void) {
int (*lse_mod_test)(void) ;
char * modname = cstring(0,0);
lt_dlhandle modp;
// Initialize libtool
lt_dlinit();
// Add local modules to search path
lt_dladdsearchdir("./modules/");
#ifdef PKGLIBDIR
// Add global modules to search path
lt_dladdsearchdir(PKGLIBDIR);
#endif
// try to load the module
modp = lt_dlopenext(modname);
// If we fail, set the flag to 0 and exit
flag = 0;
if ( ! modp ) return;
// Else make sure the module is sane
if ( !(lse_mod_test = (int (*)(void)) lt_dlsym(modp, "lse_mod_test")) ) return;
// If all is well, then the test value
// should return 1, so se the flag to this and
flag = lse_mod_test();
}
static void
add_myself(void)
{
static const char myself[] = "/proc/self/exe";
static const char moddir[] = PKGLIBDIR;
static const char eprefix[] = "${exec_prefix}";
static const char prefix[] = "${prefix}";
const char *relmoddir;
char wd[PATH_MAX], *dp;
size_t sz;
sz = readlink(myself, wd, sizeof(wd));
wd[sz] = '\0';
if ((dp = strrchr(wd, '/')) == NULL) {
return;
}
/* add the path where the binary resides */
*dp = '\0';
EDEBUG("adding %s\n", wd);
lt_dladdsearchdir(wd);
#define MEMCMPLIT(a, b) memcmp((a), (b), sizeof(b) - 1)
if (moddir[0] == '/') {
/* absolute libdir, add him */
lt_dladdsearchdir(moddir);
return;
} else if (moddir[0] == '.') {
/* relative libdir? relative to what? */
return;
} else if (memcmp(moddir, eprefix, sizeof(eprefix) - 1) == 0) {
/* take the bit after EPREFIX for catting later on */
relmoddir = moddir + sizeof(eprefix) - 1;
} else if (memcmp(moddir, prefix, sizeof(prefix) - 1) == 0) {
/* take the bit after PREFIX for catting later on */
relmoddir = moddir + sizeof(prefix) - 1;
} else {
/* don't know, i guess i'll leave ya to it */
return;
}
/* go back one level in dp */
if ((dp = strrchr(wd, '/')) == NULL) {
return;
} else if (strcmp(dp, "/bin") && strcmp(dp, "/sbin")) {
/* dp doesn't end in /bin nor /sbin */
return;
}
/* good, now we're ready to cat relmoddir to dp */
strncpy(dp, relmoddir, sizeof(wd) - (dp - wd));
EDEBUG("adding %s\n", wd);
lt_dladdsearchdir(wd);
return;
}
int
radiusd_add_load_path(const char *path)
{
if (lt_dlinit())
return 1;
return lt_dladdsearchdir(path);
}
int
mu_sv_load_add_dir (mu_sieve_machine_t mach, const char *name)
{
if (sieve_init_load_path ())
return 1;
mu_sieve_machine_add_destructor (mach, (mu_sieve_destructor_t) lt_dlexit,
NULL);
return lt_dladdsearchdir (name);
}
void moduleloader_init(const char* searchpath){
lt_dlinit();
char* path_list = strdup(searchpath);
char* path = strtok(path_list, ":");
while ( path ){
lt_dladdsearchdir(path);
path = strtok(NULL, ":");
}
free(path_list);
}
static void initlibltdl(void) {
char buffer[2000];
if (!plugins_are_initialized()) {
init_plugins();
if (getPfaEditDir(buffer)!=NULL ) {
strcpy(buffer,getPfaEditDir(buffer));
strcat(buffer,"/plugins");
lt_dladdsearchdir(strdup(buffer));
}
}
}
static void initlibltdl(void) {
char buffer[2000];
char *userConfigDir;
if (!plugins_are_initialized()) {
init_plugins();
userConfigDir = getFontForgeUserDir(Config);
if ( userConfigDir != NULL ) {
strcpy(buffer,userConfigDir);
strcat(buffer,"/plugins");
free(userConfigDir);
lt_dladdsearchdir(buffer);
}
}
}
int module_add_dir(const char *moddir)
{
char *fixed_moddir;
if (*moddir != '/') {
char cwd[1024];
cwd[0] = 0;
getcwd(cwd, sizeof(cwd));
cwd[sizeof(cwd)-1] = 0;
fixed_moddir = egg_mprintf("%s/%s", cwd, moddir);
}
else fixed_moddir = (char *)moddir;
lt_dladdsearchdir(fixed_moddir);
if (fixed_moddir != moddir) free(fixed_moddir);
return(0);
}
/**
* \brief Load system ports
*
* \param list a #GPPortInfoList
*
* Searches the system for io-drivers and appends them to the list. You would
* normally call this function once after #gp_port_info_list_new and then
* use this list in order to supply #gp_port_set_info with parameters or to do
* autodetection.
*
* \return a gphoto2 error code
**/
int
gp_port_info_list_load (GPPortInfoList *list)
{
const char *iolibs_env = getenv(IOLIBDIR_ENV);
const char *iolibs = (iolibs_env != NULL)?iolibs_env:IOLIBS;
int result;
CHECK_NULL (list);
gp_log (GP_LOG_DEBUG, "gphoto2-port-info-list",
_("Using ltdl to load io-drivers from '%s'..."),
iolibs);
lt_dlinit ();
lt_dladdsearchdir (iolibs);
result = lt_dlforeachfile (iolibs, foreach_func, list);
lt_dlexit ();
if (result < 0)
return (result);
return (GP_OK);
}
/*
* Load all available modules. Return nonzero on failure.
*/
int stp_module_load(void)
{
/* initialise libltdl */
#ifdef USE_LTDL
static int ltdl_is_initialised = 0; /* Is libltdl initialised? */
#endif
static int module_list_is_initialised = 0; /* Is the module list initialised? */
#if defined(USE_LTDL) || defined(USE_DLOPEN)
stp_list_t *dir_list; /* List of directories to scan */
stp_list_t *file_list; /* List of modules to open */
stp_list_item_t *file; /* Pointer to current module */
#endif
#ifdef USE_LTDL
if (!ltdl_is_initialised)
{
if (lt_dlinit())
{
stp_erprintf("Error initialising libltdl: %s\n", DLERROR());
return 1;
}
ltdl_is_initialised = 1;
}
/* set default search paths */
lt_dladdsearchdir(PKGMODULEDIR);
#endif
/* initialise module_list */
if (!module_list_is_initialised)
{
if (!(module_list = stp_list_create()))
return 1;
stp_list_set_freefunc(module_list, module_list_freefunc);
module_list_is_initialised = 1;
}
/* search for available modules */
#if defined (USE_LTDL) || defined (USE_DLOPEN)
if (!(dir_list = stp_list_create()))
return 1;
stp_list_set_freefunc(dir_list, stp_list_node_free_data);
if (getenv("STP_MODULE_PATH"))
{
stp_path_split(dir_list, getenv("STP_MODULE_PATH"));
}
else
{
#ifdef USE_LTDL
stp_path_split(dir_list, getenv("LTDL_LIBRARY_PATH"));
stp_path_split(dir_list, lt_dlgetsearchpath());
#else
stp_path_split(dir_list, PKGMODULEDIR);
#endif
}
#ifdef USE_LTDL
file_list = stp_path_search(dir_list, ".la");
#else
file_list = stp_path_search(dir_list, ".so");
#endif
stp_list_destroy(dir_list);
/* load modules */
file = stp_list_get_start(file_list);
while (file)
{
stp_module_open((const char *) stp_list_item_get_data(file));
file = stp_list_item_next(file);
}
stp_list_destroy(file_list);
#else /* use a static module list */
{
int i=0;
while (static_modules[i])
{
stp_module_register(static_modules[i]);
i++;
}
}
#endif
return 0;
}
BOOL SQLCreateDataSource( HWND hWnd,
LPCSTR pszDS )
{
BOOL nReturn;
void *hDLL;
BOOL (*pSQLCreateDataSource)(HWND, LPCSTR);
char *p;
char szGUILibFile[FILENAME_MAX];
int found;
if ( !hWnd )
{
inst_logPushMsg( __FILE__, __FILE__, __LINE__, LOG_CRITICAL, ODBC_ERROR_INVALID_HWND, "" );
return FALSE;
}
/*
* initialize libtool
*/
lt_dlinit();
/*
* DETERMINE PATH FOR GUI PLUGIN
*
*/
/*
* first look in the environment
*/
p = getenv( "ODBCINSTQ" );
if ( p )
{
strcpy( szGUILibFile, p );
}
else
{
SQLGetPrivateProfileString( "ODBC", "ODBCINSTQ", "", szGUILibFile, sizeof( szGUILibFile ), "odbcinst.ini" );
if ( strlen( szGUILibFile ) == 0 )
{
/*
* we need to find the extension to use as well
*/
get_lib_file( szGUILibFile, NULL );
if ( lt_dladdsearchdir( DEFLIB_PATH ) )
{
inst_logPushMsg( __FILE__, __FILE__, __LINE__, LOG_CRITICAL,
ODBC_ERROR_GENERAL_ERR, (char*)lt_dlerror() );
}
}
}
/*
* USE libtool TO LOAD PLUGIN AND CALL FUNCTION
*/
nReturn = FALSE;
found = FALSE;
hDLL = lt_dlopen( szGUILibFile );
if ( hDLL )
{
/* change the name, as it avoids it finding it in the calling lib */
pSQLCreateDataSource = (BOOL (*)(HWND, LPSTR))lt_dlsym( hDLL, "QTSQLCreateDataSources" );
if ( pSQLCreateDataSource )
nReturn = pSQLCreateDataSource(NULL,pszDS);
else
inst_logPushMsg( __FILE__, __FILE__, __LINE__, LOG_CRITICAL, ODBC_ERROR_GENERAL_ERR, (char*)lt_dlerror() );
found = TRUE;
}
else
{
/*
* try after adding the explicit path
*/
get_lib_file( szGUILibFile, DEFLIB_PATH );
hDLL = lt_dlopen( szGUILibFile );
if ( hDLL )
{
/* change the name, as it avoids it finding it in the calling lib */
pSQLCreateDataSource = (BOOL (*)(HWND))lt_dlsym( hDLL, "QTSQLCreateDataSources" );
if ( pSQLCreateDataSource )
nReturn = pSQLCreateDataSource(NULL,pszDS);
else
inst_logPushMsg( __FILE__, __FILE__, __LINE__, LOG_CRITICAL, ODBC_ERROR_GENERAL_ERR, (char*)lt_dlerror() );
found = TRUE;
}
}
if ( !found )
{
/* TRY TO PASS THROUGH TO GUI SHADOW LIB */
if ( (hDLL = lt_dlopen( "libodbcinstG.so" )) )
{
pSQLCreateDataSource = (BOOL(*)(HWND,LPSTR))lt_dlsym( hDLL, "SQLCreateDataSource" );
if ( pSQLCreateDataSource )
nReturn = pSQLCreateDataSource( NULL,pszDS );
else
inst_logPushMsg( __FILE__, __FILE__, __LINE__, LOG_CRITICAL, ODBC_ERROR_GENERAL_ERR, "" );
found = TRUE;
}
}
if ( !found )
{
inst_logPushMsg( __FILE__, __FILE__, __LINE__, LOG_CRITICAL, ODBC_ERROR_GENERAL_ERR, "" );
}
return nReturn;
}
int
gp_abilities_list_load_dir (CameraAbilitiesList *list, const char *dir,
GPContext *context)
{
CameraLibraryIdFunc id;
CameraLibraryAbilitiesFunc ab;
CameraText text;
int ret, x, old_count, new_count;
unsigned int i, p;
const char *filename;
CameraList *flist;
int count;
lt_dlhandle lh;
CHECK_NULL (list && dir);
gp_log (GP_LOG_DEBUG, "gphoto2-abilities-list",
"Using ltdl to load camera libraries from '%s'...", dir);
CHECK_RESULT (gp_list_new (&flist));
ret = gp_list_reset (flist);
if (ret < GP_OK) {
gp_list_free (flist);
return ret;
}
if (1) { /* a new block in which we can define a temporary variable */
foreach_data_t foreach_data = { NULL, GP_OK };
foreach_data.list = flist;
lt_dlinit ();
lt_dladdsearchdir (dir);
ret = lt_dlforeachfile (dir, foreach_func, &foreach_data);
lt_dlexit ();
if (ret != 0) {
gp_list_free (flist);
gp_log (GP_LOG_ERROR, "gp-abilities-list",
"Internal error looking for camlibs (%d)", ret);
gp_context_error (context,
_("Internal error looking for camlibs. "
"(path names too long?)"));
return (foreach_data.result!=GP_OK)?foreach_data.result:GP_ERROR;
}
}
count = gp_list_count (flist);
if (count < GP_OK) {
gp_list_free (flist);
return ret;
}
gp_log (GP_LOG_DEBUG, "gp-abilities-list", "Found %i "
"camera drivers.", count);
lt_dlinit ();
p = gp_context_progress_start (context, count,
_("Loading camera drivers from '%s'..."), dir);
for (i = 0; i < count; i++) {
ret = gp_list_get_name (flist, i, &filename);
if (ret < GP_OK) {
gp_list_free (flist);
return ret;
}
lh = lt_dlopenext (filename);
if (!lh) {
gp_log (GP_LOG_DEBUG, "gphoto2-abilities-list",
"Failed to load '%s': %s.", filename,
lt_dlerror ());
continue;
}
/* camera_id */
id = lt_dlsym (lh, "camera_id");
if (!id) {
gp_log (GP_LOG_DEBUG, "gphoto2-abilities-list",
"Library '%s' does not seem to "
"contain a camera_id function: %s",
filename, lt_dlerror ());
lt_dlclose (lh);
continue;
}
/*
* Make sure the camera driver hasn't been
* loaded yet.
*/
if (id (&text) != GP_OK) {
lt_dlclose (lh);
continue;
}
if (gp_abilities_list_lookup_id (list, text.text) >= 0) {
lt_dlclose (lh);
continue;
}
/* camera_abilities */
ab = lt_dlsym (lh, "camera_abilities");
if (!ab) {
gp_log (GP_LOG_DEBUG, "gphoto2-abilities-list",
"Library '%s' does not seem to "
"contain a camera_abilities function: "
"%s", filename, lt_dlerror ());
lt_dlclose (lh);
continue;
}
old_count = gp_abilities_list_count (list);
if (old_count < 0) {
lt_dlclose (lh);
continue;
}
if (ab (list) != GP_OK) {
lt_dlclose (lh);
continue;
}
lt_dlclose (lh);
new_count = gp_abilities_list_count (list);
if (new_count < 0)
continue;
/* Copy in the core-specific information */
for (x = old_count; x < new_count; x++) {
strcpy (list->abilities[x].id, text.text);
strcpy (list->abilities[x].library, filename);
}
gp_context_progress_update (context, p, i);
if (gp_context_cancel (context) == GP_CONTEXT_FEEDBACK_CANCEL) {
lt_dlexit ();
gp_list_free (flist);
return (GP_ERROR_CANCEL);
}
}
gp_context_progress_stop (context, p);
lt_dlexit ();
gp_list_free (flist);
return (GP_OK);
}
/**************************************************************************
Initialize ai stuff
**************************************************************************/
void ai_init(void)
{
bool failure = FALSE;
#if !defined(AI_MODULES) || defined(AI_MOD_STATIC_CLASSIC) || defined(AI_MOD_STATIC_THREADED)
/* First !defined(AI_MODULES) case is for default ai support. */
struct ai_type *ai;
#endif
#ifdef AI_MODULES
if (lt_dlinit()) {
failure = TRUE;
}
if (!failure) {
#ifdef DEBUG
/* First search ai modules under directory ai/<module> under
current directory. This allows us to run freeciv without
installing it. */
const char *moduledirs[] = { "default", "threaded", "stub", NULL };
int i;
for (i = 0; moduledirs[i] != NULL ; i++) {
char buf[2048];
fc_snprintf(buf, sizeof(buf), "ai/%s", moduledirs[i]);
lt_dladdsearchdir(buf);
}
#endif /* DEBUG */
/* Then search ai modules from their installation directory. */
lt_dladdsearchdir(AI_MODULEDIR);
}
#endif /* AI_MODULES */
#if defined(AI_MODULES) && !defined(AI_MOD_STATIC_CLASSIC)
if (!failure && !load_ai_module("classic")) {
failure = TRUE;
}
#else /* AI_MOD_STATIC_CLASSIC */
ai = ai_type_alloc();
init_ai(ai);
if (!fc_ai_classic_setup(ai)) {
failure = TRUE;
}
#endif /* AI_MOD_STATIC_CLASSIC */
if (failure) {
log_fatal(_("Failed to setup default AI module, cannot continue."));
exit(EXIT_FAILURE);
}
default_ai = ai;
#ifdef AI_MOD_STATIC_THREADED
ai = ai_type_alloc();
if (ai != NULL) {
init_ai(ai);
if (!fc_ai_threaded_setup(ai)) {
log_error(_("Failed to setup threaded AI module"));
}
}
#endif /* AI_MOD_STATIC_THREADED */
}
/*
* rig_load_backend
* Dynamically load a rig backend through dlopen mechanism
*/
int HAMLIB_API rig_load_backend(const char *be_name)
{
# define PREFIX "hamlib-"
lt_dlhandle be_handle;
backend_init_t be_init;
int status;
char libname[PATH_MAX];
char probefname[MAXFUNCNAMELEN];
int i;
/*
* lt_dlinit may be called several times
*
* FIXME: make static build seamless
*/
#if 0
LTDL_SET_PRELOADED_SYMBOLS();
#endif
status = lt_dlinit();
if (status) {
rig_debug(RIG_DEBUG_ERR, "rig_backend_load: lt_dlinit for %s "
"failed: %s\n", be_name, lt_dlerror());
return -RIG_EINTERNAL;
}
lt_dladdsearchdir(HAMLIB_MODULE_DIR);
rig_debug(RIG_DEBUG_VERBOSE, "rig: loading backend %s\n",be_name);
/*
* add hamlib directory here
*/
snprintf (libname, sizeof (libname), PREFIX"%s", be_name);
be_handle = lt_dlopenext (libname);
/*
* external module not found? try dlopenself for backends
* compiled in static
*/
if (!be_handle || rig_check_backend_version(be_handle, be_name, &be_init) != RIG_OK) {
rig_debug(RIG_DEBUG_VERBOSE, "rig: lt_dlopen(\"%s\") failed (%s), "
"trying static symbols...\n",
libname, lt_dlerror());
be_handle = lt_dlopen (NULL);
if (!be_handle || rig_check_backend_version(be_handle, be_name, &be_init) != RIG_OK) {
rig_debug(RIG_DEBUG_ERR, "rig: lt_dlopen(\"%s\") failed (%s)\n",
libname, lt_dlerror());
return -RIG_EINVAL;
}
}
/*
* register probe function if present
* NOTE: rig_load_backend might have been called upon a backend
* not in riglist.h! In this case, do nothing.
*/
for (i=0; i<RIG_BACKEND_MAX && rig_backend_list[i].be_name; i++) {
if (!strncmp(be_name, rig_backend_list[i].be_name, 64)) {
snprintf(probefname, MAXFUNCNAMELEN, "probeallrigs%d_%s", ABI_VERSION, be_name);
rig_backend_list[i].be_probe_all =
(rig_model_t (*)(hamlib_port_t*, rig_probe_func_t, rig_ptr_t))
lt_dlsym (be_handle, probefname);
break;
}
}
status = (*be_init)(be_handle);
return status;
}
static int
_add_load_dir (void *item, void *unused)
{
return lt_dladdsearchdir (item);
}
/**
* initializeScanRules
*
* this reads in the rules definition file for identifying the playload.
* It compiles the regular
* expressions and loads in the dynamic libraries as defined for later use
*
* @param scriptFile a file pointer to the rule definition file
*
*/
gboolean
ycInitializeScanRules (
FILE * scriptFile,
GError ** err)
{
/*
// for every rule that is "imagined" can be returned on a single call to
pcre_exec, you need to multiply that number by 6 for the correct number of
"vector" entries (and because of pcre limitation should be a multiple of 3)
*/
#define NUM_SUBSTRING_VECTS 60
const char *errorString;
int errorPos;
char eString[ESTRING_SIZE];
pcre *ruleScanner;
pcre *pluginScanner;
pcre *commentScanner;
pcre *pluginArgScanner;
pcre *signatureScanner;
const char commentScannerExp[] = "^\\s*#[^\\n]*\\n";
const char pluginScannerExp[] =
"^[[:space:]]*label[[:space:]]+([[:digit:]]+)"
"[[:space:]]+plugin[[:space:]]*([^[:space:]\\n].*)\\n";
const char ruleScannerExp[] =
"^[[:space:]]*label[[:space:]]+([[:digit:]]+)"
"[[:space:]]+regex[[:space:]]*([^\\n].*)\\n";
const char signatureScannerExp[] =
"^[[:space:]]*label[[:space:]]+([[:digit:]]+)"
"[[:space:]]+signature[[:space:]]*([^\\n].*)\\n";
const char pluginArgScannerExp[] = "[[:word:]]";
int rc;
int substringVects[NUM_SUBSTRING_VECTS];
char lineBuffer[LINE_BUF_SIZE];
int readLength;
char *captString;
unsigned int bufferOffset = 0;
int currentStartPos = 0;
int loop;
char *ltdl_lib_path = NULL;
/* first mark all plugin entries as empty, just in case */
for (loop = 0; loop < MAX_PAYLOAD_RULES; loop++) {
ruleTable[loop].ruleType = EMPTY;
}
/* initialize the hash table */
ycPortHashInitialize();
/* initialize the dynamic loader library */
rc = lt_dlinit();
if (0 != rc) {
*err = g_error_new (YAF_ERROR_DOMAIN, YAF_ERROR_IMPL,
"error initializing the dynamic loader library: \"%s\"",
lt_dlerror ());
return FALSE;
}
/* if LTDL_LIBRARY_PATH is set - add this one first */
ltdl_lib_path = getenv("LTDL_LIBRARY_PATH");
if (ltdl_lib_path) {
lt_dladdsearchdir(ltdl_lib_path);
}
#ifdef YAF_APPLABEL_PATH
/* add the applabel path based on libdir at build time */
lt_dladdsearchdir(YAF_APPLABEL_PATH);
#else
/* add /usr/local/lib/yaf to path since libtool can never find it */
lt_dladdsearchdir(YAF_SEARCH_PATH);
lt_dladdsearchdir(ALT_SEARCH_PATH);
lt_dladdsearchdir(ALT_SEARCH_PATH64);
#endif
/* create the hash table for library modules to library handle names */
if (!hcreate ((MAX_PAYLOAD_RULES * 20) / 100)) {
*err = g_error_new (YAF_ERROR_DOMAIN, YAF_ERROR_IMPL,
"couldn't create load module hash table (%d)", errno);
return FALSE;
}
/*
* take all of the rules needed to parse the rule file and compile
* them into a form that // the regular expression engine can deal with */
ruleScanner = pcre_compile(ruleScannerExp, PCRE_MULTILINE, &errorString,
&errorPos, NULL);
if (NULL == ruleScanner) {
ycDisplayScannerRuleError(eString, ESTRING_SIZE,
"couldn't build the rule scanner",
errorString, ruleScannerExp, errorPos);
*err = g_error_new(YAF_ERROR_DOMAIN,YAF_ERROR_INTERNAL, "%s", eString);
return FALSE;
}
pluginScanner = pcre_compile(pluginScannerExp, PCRE_MULTILINE,
&errorString, &errorPos, NULL);
if (NULL == pluginScanner) {
ycDisplayScannerRuleError(eString, ESTRING_SIZE,
"couldn't build the plugin scanner",
errorString, pluginScannerExp, errorPos);
*err = g_error_new(YAF_ERROR_DOMAIN,YAF_ERROR_INTERNAL, "%s", eString);
return FALSE;
}
commentScanner = pcre_compile(commentScannerExp, PCRE_MULTILINE,
&errorString, &errorPos, NULL);
if (NULL == commentScanner) {
ycDisplayScannerRuleError (eString, ESTRING_SIZE,
"couldn't build the comment scanner",
errorString, commentScannerExp, errorPos);
*err = g_error_new(YAF_ERROR_DOMAIN,YAF_ERROR_INTERNAL, "%s", eString);
return FALSE;
}
pluginArgScanner = pcre_compile(pluginArgScannerExp, PCRE_MULTILINE,
&errorString, &errorPos, NULL);
if (NULL == pluginArgScanner) {
ycDisplayScannerRuleError(eString, ESTRING_SIZE,
"couldn't build the plugin argument scanner",
errorString, pluginArgScannerExp, errorPos);
*err = g_error_new(YAF_ERROR_DOMAIN,YAF_ERROR_INTERNAL, "%s", eString);
return FALSE;
}
signatureScanner = pcre_compile(signatureScannerExp, PCRE_MULTILINE,
&errorString, &errorPos, NULL);
if (NULL == signatureScanner) {
ycDisplayScannerRuleError (eString, ESTRING_SIZE,
"couldn't build the signature scanner",
errorString, signatureScannerExp, errorPos);
*err = g_error_new(YAF_ERROR_DOMAIN,YAF_ERROR_INTERNAL, "%s", eString);
return FALSE;
}
/*
* this is the loop that does the lion's share of the rule file
* processing first read a hunk of the rule file, (this may include
* multiple lines of stuff) this gets a little bit ugly, there are a
* number of issues that have to handled; first, because there may be
* multiple lines (which is in fact likely) it has to be able to work
* its way through the buffer, a single pass of the buffer through the
* pcre engine simply won't cut it; at the end, it is possible // to have
* part of line, when this happens, it needs to copy the leftover part
* of the read into the front of the buffer, and then read again to fill in
* the rest of line. (this detail limits a single line to
* LINE_BUF_SIZE size) */
do {
readLength =
fread (lineBuffer + bufferOffset, 1, LINE_BUF_SIZE - 1 -bufferOffset,
scriptFile);
if (0 == readLength) {
if (ferror (scriptFile)) {
*err = g_error_new(YAF_ERROR_DOMAIN, YAF_ERROR_IO,
"couldn't read the rule file: %s",
strerror (errno));
return FALSE;
}
break;
}
/* fread only returns how much it read from the file - need to add
extra we put in the buffer from last read, if any */
readLength += bufferOffset;
/*
* substringVects is used by the pcre library to indicate where the
* matched substrings are in the input string, but [1] points to
* the very end of the total match, we use this to iterate through
* the readBuffer, always reset it after a read */
substringVects[0] = 0;
substringVects[1] = 0;
/* parse as much of the input buffer as possible */
while (substringVects[1] < readLength) {
#if YFDEBUG_APPLABEL
g_debug("readLength %d startPosition %d\n", readLength,
substringVects[1]);
for (loop=0; loop < 10; loop++) {
if (loop+substringVects[1] > readLength) {
break;
}
char curChar = *(lineBuffer + substringVects[1] + loop);
if (iscntrl(curChar)) {
g_debug(".");
continue;
}
if (isprint(curChar)) {
g_debug("%c", curChar);
} else {
g_debug(".");
}
}
g_debug("\n");
#endif
/* get rid of CR's and LF's at the begging, use the simple manual
* method, they gum up the regex works */
if ('\n' == *(lineBuffer + substringVects[1])
|| '\r' == *(lineBuffer + substringVects[1])) {
substringVects[1]++;
continue;
}
/* first check for comments, and eliminate them */
currentStartPos = substringVects[1];
/* need to store the current offset, if we fail to match, we
get -1 in [1] */
rc = pcre_exec (commentScanner, NULL, lineBuffer, readLength,
substringVects[1], PCRE_ANCHORED, substringVects,
NUM_SUBSTRING_VECTS);
if (rc > 0) {
#if YFDEBUG_APPLABEL
g_debug("comment match pos %d to pos %d\n",
substringVects[0], substringVects[1]);
pcre_get_substring(lineBuffer, substringVects, rc, 0,
(const char**)&captString);
g_debug("comment line is \"%s\"\n", captString);
pcre_free(captString);
#endif
continue;
}
substringVects[1] = currentStartPos;
/* scan the line to see if it is a regex statement, and get the
* arguments if it is */
rc = pcre_exec (ruleScanner, NULL, lineBuffer, readLength,
substringVects[1], PCRE_ANCHORED, substringVects,
NUM_SUBSTRING_VECTS);
if (rc > 0) {
pcre *newRule;
pcre_extra *newExtra;
/* get the first matched field from the regex rule expression
* (the label value) */
pcre_get_substring (lineBuffer, substringVects, rc, 1,
(const char **) &captString);
ruleTable[numPayloadRules].payloadLabelValue =
strtoul (captString, NULL, 10);
#if YFDEBUG_APPLABEL
g_debug("regex: rule # %u, label value %lu ",
numPayloadRules, strtoul(captString, NULL, 10));
#endif
pcre_free (captString);
/* get the second matched field from the regex rule expression
* (should be the regex) */
pcre_get_substring(lineBuffer, substringVects, rc, 2,
(const char **) &captString);
#if YF_DEBUG_APPLABEL
g_debug(" regex \"%s\"\n", captString);
#endif
newRule = pcre_compile(captString, 0, &errorString, &errorPos,
NULL);
if (NULL == newRule) {
ycDisplayScannerRuleError(eString, ESTRING_SIZE,
"error in regex application labeler rule",
errorString, captString,
errorPos);
} else {
newExtra = pcre_study (newRule, 0, &errorString);
ruleTable[numPayloadRules].ruleArgs.regexFields.
scannerExpression = newRule;
ruleTable[numPayloadRules].ruleArgs.regexFields.
scannerExtra = newExtra;
ruleTable[numPayloadRules].ruleType = REGEX;
ycPortHashInsert(ruleTable[numPayloadRules].payloadLabelValue, numPayloadRules);
numPayloadRules++;
}
pcre_free (captString);
if (MAX_PAYLOAD_RULES == numPayloadRules) {
*err = g_error_new (YAF_ERROR_DOMAIN, YAF_ERROR_LIMIT,
"maximum number of application labeler"
" rules has been reached");
return FALSE;
}
continue;
}
substringVects[1] = currentStartPos;
/* scan the line to see if it is a plugin statement, and handle the
* arguments if it is */
rc = pcre_exec (pluginScanner, NULL, lineBuffer, readLength,
substringVects[1], PCRE_ANCHORED, substringVects,
NUM_SUBSTRING_VECTS);
if (rc > 0) {
int numArgs;
char **argStrings;
/* get the first matched field from the regex rule expression
* (the lable value) */
pcre_get_substring (lineBuffer, substringVects, rc, 1,
(const char **) &captString);
ruleTable[numPayloadRules].payloadLabelValue =
strtoul (captString, NULL, 10);
#if YFDEBUG_APPLABEL
g_debug("plugin: rule # %u, label value %lu ",
numPayloadRules, strtoul(captString, NULL, 10));
#endif
pcre_free (captString);
/*
* get the second matched field, which should be the plugin
* name and all of its arguments, now we need to chunk that
* into an array of strings, ala argc, argv
*/
pcre_get_substring(lineBuffer, substringVects, rc, 2,
(const char **) &captString);
ycChunkString(captString, &numArgs, &argStrings);
if (numArgs < 2) {
g_critical("error: not enough arguments to load and call "
"a plugin, at least a library name and function"
" name are needed\n");
pcre_free(captString);
pcre_get_substring(lineBuffer, substringVects, rc, 0,
(const char **) &captString);
g_critical("input line: \"%s\"\n", captString);
} else {
ENTRY newItem;
ENTRY *foundItem;
lt_dlhandle modHandle;
lt_ptr funcPtr;
ruleTable[numPayloadRules].ruleType = PLUGIN;
ruleTable[numPayloadRules].ruleArgs.pluginArgs.numArgs =
numArgs;
ruleTable[numPayloadRules].ruleArgs.pluginArgs.pluginArgs =
argStrings;
newItem.key = strdup(argStrings[0]);
if (NULL == newItem.key) {
g_error("out of memory error\n");
for (loop = 0; loop < numArgs; loop++) {
free ((char *) (argStrings[loop]));
}
free(argStrings);
return FALSE;
}
newItem.data = NULL;
foundItem = hsearch(newItem, FIND);
if (NULL == foundItem) {
modHandle = lt_dlopenext(newItem.key);
if (NULL == modHandle) {
g_critical("Couldn't open library \"%s\": %s",
argStrings[0], lt_dlerror());
g_critical("Search path set to %s",
lt_dlgetsearchpath());
g_critical("Set LTDL_LIBRARY_PATH to correct"
" location.");
for (loop = 0; loop < numArgs; loop++) {
free((char *) (argStrings[loop]));
}
free(argStrings);
pcre_free(captString);
continue;
} else {
#if YFDEBUG_APPLABEL
const lt_dlinfo *info = lt_dlgetinfo(modHandle);
g_debug("Loading %s plugin from %s", info->name, info->filename);
#endif
}
newItem.data = (void *)modHandle;
hsearch(newItem, ENTER);
} else {
modHandle = (lt_dlhandle)foundItem->data;
}
funcPtr = lt_dlsym(modHandle, argStrings[1]);
if (NULL == funcPtr) {
g_critical("couldn't find function \"%s\" in library"
" \"%s\"\n", argStrings[1], argStrings[0]);
for (loop = 0; loop < numArgs; loop++) {
free ((char *) (argStrings[loop]));
}
free (argStrings);
pcre_free (captString);
continue;
}
ruleTable[numPayloadRules].ruleArgs.pluginArgs.func =
(ycScannerPlugin_fn) funcPtr;
ycPortHashInsert(ruleTable[numPayloadRules].payloadLabelValue, numPayloadRules);
numPayloadRules++;
}
pcre_free(captString);
if (MAX_PAYLOAD_RULES == numPayloadRules) {
g_warning ("maximum number of rules has been reached\n");
return TRUE;
}
continue;
}
substringVects[1] = currentStartPos;
/* scan the line to see if it is a signature, and get the
* arguments if it is */
rc = pcre_exec(signatureScanner, NULL, lineBuffer, readLength,
substringVects[1], PCRE_ANCHORED, substringVects,
NUM_SUBSTRING_VECTS);
if (rc > 0) {
pcre *newRule;
pcre_extra *newExtra;
/* get the first matched field from the regex rule expression
* (the label value) */
pcre_get_substring(lineBuffer, substringVects, rc, 1,
(const char **) &captString);
sigTable[numSigRules].payloadLabelValue = strtoul(captString, NULL,
10);
#if YFDEBUG_APPLABEL
g_debug("signature: rule # %u, label value %lu ",
numSigRules, strtoul(captString, NULL, 10));
#endif
pcre_free (captString);
/* get the second matched field from the regex rule expression
* (should be the regex) */
pcre_get_substring(lineBuffer, substringVects, rc, 2,
(const char **) &captString);
#if YFDEBUG_APPLABEL
g_debug(" signature \"%s\"\n", captString);
#endif
newRule = pcre_compile(captString, 0, &errorString, &errorPos,
NULL);
if (NULL == newRule) {
ycDisplayScannerRuleError (eString, ESTRING_SIZE,
"error in signature application "
"labeler rule", errorString,
captString, errorPos);
} else {
newExtra = pcre_study (newRule, 0, &errorString);
sigTable[numSigRules].ruleArgs.regexFields.
scannerExpression = newRule;
sigTable[numSigRules].ruleArgs.regexFields.
scannerExtra = newExtra;
sigTable[numSigRules].ruleType = SIGNATURE;
numSigRules++;
}
pcre_free(captString);
if (MAX_PAYLOAD_RULES == numSigRules) {
*err = g_error_new(YAF_ERROR_DOMAIN, YAF_ERROR_LIMIT,
"maximum number of signature rules has "
"been reached");
return FALSE;
}
continue;
}
substringVects[1] = currentStartPos;
/* pcre_free (captString);*/
#if YFDEBUG_APPLABEL
g_debug("plugin args: ");
for (loop = 0; loop < numArgs; loop++) {
g_debug("\"%s\" ", (*argStrings)[loop]);
}
g_debug("\n");
#endif
/*
* check to see if we have partial text left over at the end of
* the read buffer, if we copy it to the front of the read
* buffer, and on the next read, read a little less to
* compensate for the left over amount */
if ((PCRE_ERROR_NOMATCH == rc) && (substringVects[1] < readLength)
&& !feof (scriptFile)) {
memmove (lineBuffer, lineBuffer + substringVects[1],
readLength - substringVects[1]);
bufferOffset = readLength - substringVects[1];
break;
} else if (PCRE_ERROR_NOMATCH == rc && feof (scriptFile)) {
/* this is an error, we have crap left over at the end of the
* file that we can't parse! */
g_critical("unparsed text at the end of the application labeler"
" rule file!\n");
break;
}
}
} while (!ferror (scriptFile) && !feof (scriptFile));
/*
* get rid of the module handle lookup hash; this creates a mem leak of
* the module handles, they can't be freed any longer (although this is a
* crappy hash, and iterating the hash is not possible....) */
hdestroy();
g_debug("Application Labeler accepted %d rules.", numPayloadRules);
g_debug("Application Labeler accepted %d signatures.", numSigRules);
pcre_free(ruleScanner);
pcre_free(pluginScanner);
pcre_free(commentScanner);
pcre_free(pluginArgScanner);
pcre_free(signatureScanner);
/* debug */
return TRUE;
}
