Ejemplo n.º 1
0
void do_open( char_data* ch, char* argument )
{
  thing_data*  thing;
  obj_data*      obj;
  exit_data*    door;

  if( is_confused_pet( ch ) )
    return;

  if( ( thing = one_thing( ch, argument, "open",
    (thing_array*) &ch->in_room->exits, ch->array,
    &ch->contents ) ) == NULL )
    return;

  if( ( obj = object( thing ) ) != NULL ) {
    include_closed = FALSE;
    open_object( ch, obj );
    include_closed = TRUE;
    return;
    }

  if( ( door = exit( thing ) ) != NULL ) {
    open_door( ch, door );   
    return;
    }

  send( ch, "%s isn't something you can open.\n\r", thing );
}
Ejemplo n.º 2
0
Archivo: XlcDL.c Proyecto: iquiw/xsrc
static XIM
_XDynamicOpenIM(XLCd lcd, Display *display, XrmDatabase rdb,
                char *res_name, char *res_class)
{
    XIM im = (XIM)NULL;
    char lc_dir[BUFSIZE];
    char *lc_name;
    dynamicOpenProcp im_openIM = (dynamicOpenProcp)NULL;
    int count;
    XI18NObjectsList objects_list = xi18n_objects_list;

    lc_name = lcd->core->name;

    if (_XlcLocaleLibDirName(lc_dir, BUFSIZE, lc_name) == NULL) return (XIM)0;

    count = lc_count;
    for (; count-- > 0; objects_list++) {
        if (objects_list->type != XIM_OBJECT ||
                strcmp(objects_list->locale_name, lc_name)) continue;

        if (!open_object (objects_list, lc_dir))
            continue;

        im_openIM = (dynamicOpenProcp)fetch_symbol(objects_list, objects_list->open);
        if (!im_openIM) continue;
        im = (*im_openIM)(lcd, display, rdb, res_name, res_class);
        if (im != (XIM)NULL) {
            break;
        }

        close_object (objects_list);
    }
    return (XIM)im;
}
Ejemplo n.º 3
0
Archivo: XlcDL.c Proyecto: aosm/X11
XLCd
_XlcDynamicLoad(const char *lc_name)
{
    XLCd lcd = (XLCd)NULL;
    dynamicLoadProc lc_loader = (dynamicLoadProc)NULL;
    int count;
    XI18NObjectsList objects_list;
    char lc_dir[BUFSIZE];

    if (lc_name == NULL) return (XLCd)NULL;

    if (_XlcLocaleDirName(lc_dir, BUFSIZE, (char *)lc_name) == (char*)NULL)
	return (XLCd)NULL;

    resolve_object(lc_dir, lc_name);

    objects_list = xi18n_objects_list;
    count = lc_count;
    for (; count-- > 0; objects_list++) {
        if (objects_list->type != XLC_OBJECT ||
	    strcmp(objects_list->locale_name, lc_name)) continue;
	if (!open_object (objects_list, lc_dir))
	    continue;

	lc_loader = (dynamicLoadProc)fetch_symbol (objects_list, objects_list->open);
	if (!lc_loader) continue;
	lcd = (*lc_loader)(lc_name);
	if (lcd != (XLCd)NULL) {
	    break;
	}
	
	close_object (objects_list);
    }
    return (XLCd)lcd;
}
Ejemplo n.º 4
0
static void * do_actual_load(const char * filename, elf_t * lib, int flags) {
	(void)flags;

	if (!lib) {
		last_error = "could not open library (not found, or other failure)";
		return NULL;
	}

	size_t lib_size = object_calculate_size(lib);

	if (lib_size < 4096) {
		lib_size = 4096;
	}

	uintptr_t load_addr = (uintptr_t)malloc(lib_size);
	object_load(lib, load_addr);

	object_postload(lib);

	node_t * item;
	while (item = list_pop(lib->dependencies)) {

		elf_t * lib = open_object(item->value);

		if (!lib) {
			free((void *)load_addr);
			last_error = "Failed to load a dependency.";
			return NULL;
		}

		if (!lib->loaded) {
			do_actual_load(item->value, lib, 0);
			TRACE_LD("Loaded %s at 0x%x", item->value, lib->base);
		}

	}

	TRACE_LD("Relocating %s", filename);
	object_relocate(lib);

	fclose(lib->file);

	if (lib->ctors) {
		for (size_t i = 0; i < lib->ctors_size; i += sizeof(uintptr_t)) {
			TRACE_LD(" 0x%x()", lib->ctors[i]);
			lib->ctors[i]();
		}
	}

	if (lib->init) {
		lib->init();
	}

	return (void *)lib;

}
int32_t open_system_objects(container_handle_t *ct)
{
    int32_t ret;
    object_handle_t *obj;

    ct->base_blk = ct->sb.base_blk;
    
    /* open BASE object */
    ret = open_object(ct, ct->sb.base_id, ct->sb.base_inode_no, &obj);
    if (ret < 0)
    {
        LOG_ERROR("Open base object failed. ct_name(%s) ret(%d)\n", ct->name, ret);
        return ret;
    }
    
    ofs_init_sm(&ct->bsm, obj, ct->sb.base_first_free_block, ct->sb.base_free_blocks);

    /* open SPACE object */
    ret = open_object(ct, ct->sb.space_id, ct->sb.space_inode_no, &obj);
    if (ret < 0)
    {
        LOG_ERROR("Open space object failed. ct_name(%s) ret(%d)\n", ct->name, ret);
        return ret;
    }
    
    ofs_init_sm(&ct->sm, obj, ct->sb.first_free_block, ct->sb.free_blocks);

    /* open $OBJID object */
    ret = open_object(ct, ct->sb.objid_id, ct->sb.objid_inode_no, &obj);
    if (ret < 0)
    {
        LOG_ERROR("Open objid object failed. ct_name(%s) ret(%d)\n", ct->name, ret);
        return ret;
    }

    ct->id_obj = obj;

    return 0;
}
Ejemplo n.º 6
0
static void * dlopen_ld(const char * filename, int flags) {
	TRACE_LD("dlopen(%s,0x%x)", filename, flags);

	elf_t * lib = open_object(filename);

	if (lib->loaded) {
		return lib;
	}

	void * ret = do_actual_load(filename, lib, flags);
	TRACE_LD("Loaded %s at 0x%x", filename, lib->base);
	return ret;
}
Ejemplo n.º 7
0
Archivo: XlcDL.c Proyecto: iquiw/xsrc
static Bool
_XDynamicRegisterIMInstantiateCallback(
    XLCd	 lcd,
    Display	*display,
    XrmDatabase	 rdb,
    char	*res_name,
    char        *res_class,
    XIDProc	 callback,
    XPointer	 client_data)
{
    char lc_dir[BUFSIZE];
    char *lc_name;
    dynamicRegisterCBProcp im_registerIM = (dynamicRegisterCBProcp)NULL;
    Bool ret_flag = False;
    int count;
    XI18NObjectsList objects_list = xi18n_objects_list;
#if defined(hpux)
    int getsyms_cnt, i;
    struct shl_symbol *symbols;
#endif

    lc_name = lcd->core->name;

    if (_XlcLocaleLibDirName(lc_dir, BUFSIZE, lc_name) == NULL) return False;

    count = lc_count;
    for (; count-- > 0; objects_list++) {
        if (objects_list->type != XIM_OBJECT ||
                strcmp(objects_list->locale_name, lc_name)) continue;

        if (!open_object (objects_list, lc_dir))
            continue;
        im_registerIM = (dynamicRegisterCBProcp)fetch_symbol(objects_list,
                        objects_list->im_register);
        if (!im_registerIM) continue;
        ret_flag = (*im_registerIM)(lcd, display, rdb,
                                    res_name, res_class,
                                    callback, client_data);
        if (ret_flag) break;

        close_object (objects_list);
    }
    return (Bool)ret_flag;
}
Ejemplo n.º 8
0
Archivo: XlcDL.c Proyecto: iquiw/xsrc
static XOM
_XDynamicOpenOM(XLCd lcd, Display *display, XrmDatabase rdb,
                _Xconst char *res_name, _Xconst char *res_class)
{
    XOM om = (XOM)NULL;
    int count;
    char lc_dir[BUFSIZE];
    char *lc_name;
    dynamicIOpenProcp om_openOM = (dynamicIOpenProcp)NULL;
    XI18NObjectsList objects_list = xi18n_objects_list;
#if defined(hpux)
    int getsyms_cnt, i;
    struct shl_symbol *symbols;
#endif

    lc_name = lcd->core->name;

    if (_XlcLocaleLibDirName(lc_dir, BUFSIZE, lc_name) == NULL) return (XOM)0;

    count = lc_count;
    for (; count-- > 0; objects_list++) {
        if (objects_list->type != XOM_OBJECT ||
                strcmp(objects_list->locale_name, lc_name)) continue;
        if (!open_object (objects_list, lc_dir))
            continue;

        om_openOM = (dynamicIOpenProcp)fetch_symbol(objects_list, objects_list->open);
        if (!om_openOM) continue;
        om = (*om_openOM)(lcd, display, rdb, res_name, res_class);
        if (om != (XOM)NULL) {
            break;
        }
        close_object(objects_list);
    }
    return (XOM)om;
}
Ejemplo n.º 9
0
int main(int argc, char * argv[]) {

	char * file = argv[1];
	size_t arg_offset = 1;

	if (!strcmp(argv[1], "-e")) {
		arg_offset = 3;
		file = argv[2];
	}

	char * trace_ld_env = getenv("LD_DEBUG");
	if (trace_ld_env && (!strcmp(trace_ld_env,"1") || !strcmp(trace_ld_env,"yes"))) {
		__trace_ld = 1;
	}

	dumb_symbol_table = hashmap_create(10);
	glob_dat = hashmap_create(10);
	objects_map = hashmap_create(10);

	ld_exports_t * ex = ld_builtin_exports;
	while (ex->name) {
		hashmap_set(dumb_symbol_table, ex->name, ex->symbol);
		ex++;
	}

	elf_t * main_obj = open_object(file);
	_main_obj = main_obj;

	if (!main_obj) {
		fprintf(stderr, "%s: error: failed to open object '%s'.\n", argv[0], file);
		return 1;
	}

	size_t main_size = object_calculate_size(main_obj);
	uintptr_t end_addr = object_load(main_obj, 0x0);
	object_postload(main_obj);

	object_find_copy_relocations(main_obj);

	hashmap_t * libs = hashmap_create(10);

	list_t * ctor_libs = list_create();
	list_t * init_libs = list_create();

	TRACE_LD("Loading dependencies.");
	node_t * item;
	while (item = list_pop(main_obj->dependencies)) {
		while (end_addr & 0xFFF) {
			end_addr++;
		}

		char * lib_name = item->value;
		if (!strcmp(lib_name, "libg.so")) goto nope;
		elf_t * lib = open_object(lib_name);
		if (!lib) {
			fprintf(stderr, "Failed to load dependency '%s'.\n", lib_name);
			return 1;
		}
		hashmap_set(libs, lib_name, lib);

		TRACE_LD("Loading %s at 0x%x", lib_name, end_addr);
		end_addr = object_load(lib, end_addr);
		object_postload(lib);
		TRACE_LD("Relocating %s", lib_name);
		object_relocate(lib);

		fclose(lib->file);

		/* Execute constructors */
		if (lib->ctors) {
			list_insert(ctor_libs, lib);
		}
		if (lib->init) {
			list_insert(init_libs, lib);
		}

nope:
		free(item);
	}

	TRACE_LD("Relocating main object");
	object_relocate(main_obj);
	TRACE_LD("Placing heap at end");
	while (end_addr & 0xFFF) {
		end_addr++;
	}

	char * ld_no_ctors = getenv("LD_DISABLE_CTORS");
	if (ld_no_ctors && (!strcmp(ld_no_ctors,"1") || !strcmp(ld_no_ctors,"yes"))) {
		TRACE_LD("skipping ctors because LD_DISABLE_CTORS was set");
	} else {
		foreach(node, ctor_libs) {
			elf_t * lib = node->value;
			if (lib->ctors) {
				TRACE_LD("Executing ctors...");
				for (size_t i = 0; i < lib->ctors_size; i += sizeof(uintptr_t)) {
					TRACE_LD(" 0x%x()", lib->ctors[i]);
					lib->ctors[i]();
				}
			}
		}
	}