| /* |
| * Copyright (c) 2019, The Linux Foundation. All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions are |
| * met: |
| * * Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * * Redistributions in binary form must reproduce the above |
| * copyright notice, this list of conditions and the following |
| * disclaimer in the documentation and/or other materials provided |
| * with the distribution. |
| * * Neither the name of The Linux Foundation nor the names of its |
| * contributors may be used to endorse or promote products derived |
| * from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED |
| * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
| * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT |
| * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS |
| * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |
| * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
| * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR |
| * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, |
| * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE |
| * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN |
| * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| #ifndef FARF_ERROR |
| #define FARF_ERROR 1 |
| #endif |
| |
| #include <assert.h> |
| #include "verify.h" |
| #include "HAP_farf.h" |
| #include "HAP_pls.h" |
| #include "mutex.h" |
| #include "mod_table.h" |
| #include "platform_libs.h" |
| #include "remote64.h" |
| #include "uthash.h" |
| #include "AEEstd.h" |
| #include "AEEStdErr.h" |
| #include "sbuf_parser.h" |
| |
| #include <dlfcn.h> |
| |
| #define DLOPEN dlopen |
| #define DLCLOSE dlclose |
| #define DLSYM dlsym |
| #define DLERROR dlerror |
| |
| /** |
| * structure for the mod table |
| * |
| * you need to define a rw_mutex type and its read/write lock/unlock api's |
| * which are under the RW_MUTEX namespace. |
| * |
| * this library defines 2 functions for opening modules, open_static and |
| * open_dynamic. Both return a handle that should be closed via close. |
| * |
| * you can also register a const handle, an invoke function for a known handle |
| * value. since handle keys are allocated, you should pick handle values that are |
| * not going to be returned by malloc (0, or odd). |
| */ |
| struct static_mod_table { |
| RW_MUTEX_T mut; |
| struct static_mod* staticModOverrides; |
| struct static_mod* staticMods; |
| struct const_mod* constMods; |
| boolean bInit; |
| }; |
| |
| struct open_mod_table { |
| RW_MUTEX_T mut; |
| struct open_mod* openMods; |
| struct static_mod_table* smt; |
| }; |
| |
| typedef int (*invoke_fn)(uint32, remote_arg*); |
| typedef int (*handle_invoke_fn)(remote_handle64, uint32, remote_arg*); |
| struct static_mod { |
| invoke_fn invoke; |
| handle_invoke_fn handle_invoke; |
| UT_hash_handle hh; |
| char uri[1]; |
| }; |
| |
| struct const_mod { |
| invoke_fn invoke; |
| handle_invoke_fn handle_invoke; |
| uint32 key; |
| remote_handle64 h64; |
| UT_hash_handle hh; |
| char uri[1]; |
| }; |
| |
| struct parsed_uri { |
| const char *file; |
| int filelen; |
| const char *sym; |
| int symlen; |
| const char *ver; |
| int verlen; |
| }; |
| |
| struct open_mod { |
| void* dlhandle; |
| invoke_fn invoke; |
| handle_invoke_fn handle_invoke; |
| uint64 key; |
| UT_hash_handle hh; |
| remote_handle64 h64; |
| int refs; |
| struct parsed_uri vals; |
| char uri[1]; |
| }; |
| |
| static int static_mod_table_ctor(struct static_mod_table* me) { |
| if(me->bInit == 0) { |
| RW_MUTEX_CTOR(me->mut); |
| me->staticMods = 0; |
| me->staticModOverrides = 0; |
| me->bInit = 1; |
| } |
| return 0; |
| } |
| |
| static void static_mod_table_dtor_imp(struct static_mod_table* me) { |
| struct static_mod *sm, *stmp; |
| struct const_mod *dm, *ftmp; |
| if(me->bInit != 0) { |
| if( me->staticMods || me->constMods || me->staticModOverrides) { |
| RW_MUTEX_LOCK_WRITE(me->mut); |
| HASH_ITER(hh, me->staticMods, sm, stmp) { |
| if(me->staticMods) { |
| HASH_DEL(me->staticMods,sm); |
| } |
| free(sm); |
| sm = NULL; |
| } |
| HASH_ITER(hh, me->staticModOverrides, sm, stmp) { |
| if(me->staticModOverrides) { |
| HASH_DEL(me->staticModOverrides,sm); |
| } |
| free(sm); |
| sm = NULL; |
| } |
| HASH_ITER(hh, me->constMods, dm, ftmp) { |
| if(me->constMods) { |
| HASH_DEL(me->constMods,dm); |
| } |
| free(dm); |
| dm = NULL; |
| } |
| RW_MUTEX_UNLOCK_WRITE(me->mut); |
| } |
| RW_MUTEX_DTOR(me->mut); |
| me->staticMods = 0; |
| me->staticModOverrides = 0; |
| me->bInit = 0; |
| } |
| } |
| |
| static int open_mod_table_ctor_imp(void* ctx, void* data) { |
| struct open_mod_table* me = (struct open_mod_table*)data; |
| RW_MUTEX_CTOR(me->mut); |
| me->openMods = 0; |
| me->smt = (struct static_mod_table*) ctx; |
| return 0; |
| } |
| |
| static int open_mod_handle_close(struct open_mod *mod, remote_handle64 h); |
| |
| static void open_mod_table_dtor_imp(void* data) { |
| struct open_mod_table* me = (struct open_mod_table*)data; |
| struct open_mod *dm, *ftmp; |
| if( me->openMods) { |
| RW_MUTEX_LOCK_WRITE(me->mut); |
| HASH_ITER(hh, me->openMods, dm, ftmp) { |
| if(me->openMods) { |
| HASH_DEL(me->openMods,dm); |
| } |
| if(dm->h64) { |
| (void)open_mod_handle_close(dm, dm->h64); |
| } |
| if(dm->dlhandle) { |
| DLCLOSE(dm->dlhandle); |
| } |
| free(dm); |
| } |
| RW_MUTEX_UNLOCK_WRITE(me->mut); |
| } |
| RW_MUTEX_DTOR(me->mut); |
| me->openMods = 0; |
| } |
| static int open_mod_table_open_from_static(struct open_mod_table* me, |
| struct static_mod** tbl, |
| const char* uri, |
| remote_handle* handle); |
| |
| static int open_mod_table_open_static_override(struct open_mod_table* me, const char* uri, remote_handle* handle) { |
| FARF(HIGH, "open_mod_table_open_static_override"); |
| return open_mod_table_open_from_static(me, &me->smt->staticModOverrides, uri, handle); |
| } |
| |
| |
| static int open_mod_table_open_static(struct open_mod_table* me, const char* uri, remote_handle* handle) { |
| FARF(HIGH, "open_mod_table_open_static"); |
| return open_mod_table_open_from_static(me, &me->smt->staticMods, uri, handle); |
| } |
| |
| static int static_mod_add(struct static_mod_table* me, struct static_mod** tbl, const char* uri, |
| int(*invoke)(uint32 sc, remote_arg* pra), |
| int(*handle_invoke)(remote_handle64, uint32 sc, remote_arg* pra)) { |
| int nErr = AEE_SUCCESS; |
| struct static_mod *sm = 0; |
| int len = std_strlen(uri) + 1; |
| VERIFYC(NULL != (sm = ((struct static_mod*)calloc(1, sizeof(struct static_mod) + len))), AEE_ENOMEMORY); |
| std_strlcpy(sm->uri, uri, len); |
| sm->invoke = invoke; |
| sm->handle_invoke = handle_invoke; |
| RW_MUTEX_LOCK_WRITE(me->mut); |
| HASH_ADD_STR(*tbl, uri, sm); |
| RW_MUTEX_UNLOCK_WRITE(me->mut); |
| bail: |
| if(nErr != AEE_SUCCESS) { |
| VERIFY_EPRINTF("Error %x: static module addition failed\n", nErr); |
| if(sm) { |
| free(sm); |
| sm = NULL; |
| } |
| } |
| return nErr; |
| } |
| |
| static int static_mod_table_register_static_override(struct static_mod_table* me, const char* uri, int(*pfn)(uint32 sc, remote_arg* pra)) { |
| return static_mod_add(me, &me->staticModOverrides, uri, pfn, 0); |
| } |
| static int static_mod_table_register_static_override1(struct static_mod_table* me, const char* uri, int(*pfn)(remote_handle64, uint32 sc, remote_arg* pra)) { |
| return static_mod_add(me, &me->staticModOverrides, uri, 0, pfn); |
| } |
| static int static_mod_table_register_static(struct static_mod_table* me, const char* uri, int(*pfn)(uint32 sc, remote_arg* pra)) { |
| return static_mod_add(me, &me->staticMods, uri, pfn, 0); |
| } |
| static int static_mod_table_register_static1(struct static_mod_table* me, const char* uri, int(*pfn)(remote_handle64,uint32 sc, remote_arg* pra)) { |
| return static_mod_add(me, &me->staticMods, uri, 0, pfn); |
| } |
| |
| |
| static int static_mod_table_register_const_handle(struct static_mod_table* me, remote_handle local, |
| remote_handle64 remote, const char* uri, |
| int(*invoke)(uint32 sc, remote_arg* pra), |
| int(*handle_invoke)(remote_handle64, uint32 sc, remote_arg* pra) |
| ) { |
| int nErr = AEE_SUCCESS; |
| int len = std_strlen(uri) + 1; |
| struct const_mod *dm = 0, *dmOld; |
| VERIFYC(NULL != (dm = ((struct const_mod*)calloc(1, sizeof(struct open_mod) + len))), AEE_ENOMEMORY); |
| dm->key = local; |
| dm->invoke = invoke; |
| dm->handle_invoke = handle_invoke; |
| dm->h64 = remote; |
| std_strlcpy(dm->uri, uri, len); |
| |
| RW_MUTEX_LOCK_WRITE(me->mut); |
| HASH_FIND_INT(me->constMods, &local, dmOld); |
| if(dmOld == 0) { |
| HASH_ADD_INT(me->constMods, key, dm); |
| } |
| RW_MUTEX_UNLOCK_WRITE(me->mut); |
| nErr = dmOld != 0 ? -1 : nErr; |
| bail: |
| if(nErr != AEE_SUCCESS) { |
| VERIFY_EPRINTF("Error %x: failed to register const handle in modtable\n", nErr); |
| if(dm) { |
| free(dm); |
| dm = NULL; |
| } |
| } |
| return nErr; |
| } |
| |
| static int open_mod_handle_open(struct open_mod *mod, const char* name, |
| remote_handle64 *ph) { |
| int nErr = AEE_SUCCESS; |
| remote_arg args[3]; |
| int32_t len = strlen(name) + 1; |
| args[0].buf.pv = &len; |
| args[0].buf.nLen = sizeof(len); |
| args[1].buf.pv = (void*)name; |
| args[1].buf.nLen = len; |
| nErr = mod->handle_invoke(0,REMOTE_SCALARS_MAKEX(0,0,2,0,0,1),args); |
| if(!nErr) { |
| *ph = args[2].h64; |
| } |
| FARF(HIGH, "allocated %x", *ph); |
| return nErr; |
| } |
| |
| static int open_mod_handle_close(struct open_mod *mod, remote_handle64 h) { |
| int nErr; |
| remote_arg args[1]; |
| args[0].h64 = h; |
| FARF(HIGH, "releasing %x", h); |
| nErr = mod->handle_invoke(0,REMOTE_SCALARS_MAKEX(0,1,0,0,1,0),args); |
| return nErr; |
| } |
| |
| static int notqmark(struct sbuf *buf) { |
| return sbuf_notchar(buf, '?'); |
| } |
| static int notandoreq(struct sbuf *buf) { |
| return sbuf_notchars(buf, "&="); |
| } |
| static int notand(struct sbuf *buf) { |
| return sbuf_notchar(buf, '&'); |
| } |
| |
| static int parse_uri(const char *uri, int urilen, struct parsed_uri *out) { |
| // "file:///librhtest_skel.so?rhtest_skel_handle_invoke&_modver=1.0" |
| int nErr = 0; |
| char *name, *value; |
| int nameLen, valueLen; |
| struct sbuf buf; |
| FARF(HIGH, "parse_uri %s %d", uri, urilen); |
| memset(out, 0, sizeof(*out)); |
| //initialize |
| sbuf_parser_init(&buf, uri, urilen); |
| |
| //parse until question mark |
| VERIFYC(sbuf_string(&buf, "file://"), AEE_EINVALIDFORMAT); |
| |
| //ignore the starting / |
| (void)sbuf_string(&buf, "/"); |
| |
| out->file = sbuf_cur(&buf); |
| VERIFY(sbuf_many1(&buf, notqmark)); |
| out->filelen = sbuf_cur(&buf) - out->file; |
| FARF(HIGH, "file:%.*s %d", out->filelen, out->file, out->filelen); |
| VERIFY(sbuf_char(&buf, '?')); |
| out->sym = sbuf_cur(&buf); |
| VERIFY(sbuf_many1(&buf, notand)); |
| out->symlen = sbuf_cur(&buf) - out->sym; |
| assert(out->sym + out->symlen <= uri + urilen); |
| FARF(HIGH, "sym:%.*s %d", out->symlen, out->sym, out->symlen); |
| |
| if(!sbuf_end(&buf) && sbuf_char(&buf, '&')) { |
| //parse each query |
| while(!sbuf_end(&buf)) { |
| //record where the name starts |
| name = sbuf_cur(&buf); |
| |
| //name is valid until '=' or '&' |
| VERIFY(sbuf_many1(&buf, notandoreq)); |
| nameLen = sbuf_cur(&buf) - name; |
| |
| value = 0; |
| valueLen = 0; |
| //if the next char is a '=' then we also get a value |
| if(sbuf_char(&buf, '=')) { |
| value = sbuf_cur(&buf); |
| |
| //value is until the next query that starts with '&' |
| VERIFY(sbuf_many1(&buf, notand)); |
| valueLen = sbuf_cur(&buf) - value; |
| } |
| //expect '&' or end |
| sbuf_char(&buf, '&'); |
| if(!std_strncmp(name, "_modver", nameLen)) { |
| out->ver = value; |
| out->verlen = valueLen; |
| } |
| } |
| } |
| bail: |
| if(out->filelen) { |
| FARF(HIGH, "parse_uri file: %.*s", out->filelen, out->file); |
| } |
| if(out->symlen) { |
| FARF(HIGH, "parse_uri sym: %.*s", out->symlen, out->sym); |
| } |
| if(out->verlen) { |
| FARF(HIGH, "parse_uri version: %.*s", out->verlen, out->ver); |
| } |
| FARF(HIGH, "parse_uri done: %s %d err:%x", uri, urilen, nErr); |
| if(nErr != AEE_SUCCESS) { |
| VERIFY_EPRINTF("Error %x: parseuri failed for uri %s, urilen %d\n", nErr, uri, urilen); |
| } |
| return nErr; |
| } |
| |
| static int open_mod_table_open_dynamic(struct open_mod_table* me, const char* uri, remote_handle* handle, char* dlStr, int dlerrorLen, int* pdlErr) |
| { |
| int nErr = AEE_SUCCESS, dlErr = 0; |
| struct open_mod *dm = 0, *dmOld; |
| int len = strlen(uri); |
| int tmplen = len*2 + sizeof("file:///lib_skel.so?_skel_handle_invoke&_modver=1.0") + 1; |
| char *tmp = 0; |
| FARF(HIGH, "open_mod_table_open_dynamic"); |
| VERIFYC(NULL != (tmp = calloc(1, tmplen)), AEE_ENOMEMORY); |
| VERIFYC(NULL != (dm = ((struct open_mod*)calloc(1, sizeof(struct open_mod) + len + 1))), AEE_ENOMEMORY); |
| std_memmove(dm->uri, uri, len + 1); |
| FARF(HIGH, "calling parse_uri"); |
| (void)parse_uri(dm->uri, len, &dm->vals); |
| FARF(HIGH, "done calling parse_uri"); |
| FARF(HIGH, "vals %d %d %d", dm->vals.filelen, dm->vals.symlen, dm->vals.verlen); |
| if(dm->vals.filelen) { |
| int rv = std_snprintf(tmp, tmplen, "%.*s", dm->vals.filelen, dm->vals.file); |
| VERIFYC(tmplen >= rv, AEE_EBADSIZE); |
| } else { |
| int rv; |
| rv = std_snprintf(tmp, tmplen, "lib%s_skel.so", uri); |
| VERIFYC(tmplen >= rv, AEE_EBADSIZE); |
| } |
| FARF(HIGH, "calling dlopen for %s", tmp); |
| dm->dlhandle = DLOPEN(tmp,RTLD_NOW); |
| FARF(HIGH, "got %p for dlopen %s", dm->dlhandle, tmp); |
| VERIFY(!(nErr = (dlErr = dm->dlhandle == 0 ? -5 : 0))); |
| |
| if(dm->vals.symlen) { |
| int rv = std_snprintf(tmp, tmplen, "%.*s", dm->vals.symlen, dm->vals.sym); |
| VERIFYC(tmplen >= rv, AEE_EBADSIZE); |
| } else { |
| int rv = std_snprintf(tmp, tmplen, "%s_skel_invoke", uri); |
| VERIFYC(tmplen >= rv, AEE_EBADSIZE); |
| } |
| |
| FARF(HIGH, "calling dlsym for %s", tmp); |
| if(dm->vals.verlen && 0 == std_strncmp(dm->vals.ver, "1.0", dm->vals.verlen)) { |
| dm->handle_invoke = (handle_invoke_fn) DLSYM(dm->dlhandle, tmp); |
| } else { |
| dm->invoke = (invoke_fn) DLSYM(dm->dlhandle, tmp); |
| } |
| FARF(HIGH, "dlsym returned %p %p", dm->invoke, dm->handle_invoke); |
| VERIFYC(!(dlErr = dm->invoke || dm->handle_invoke ? 0 : AEE_ENOSUCHSYMBOL), AEE_ENOSUCHSYMBOL); |
| |
| dm->key = (uint32)(uintptr_t)dm; |
| dm->refs = 1; |
| if(dm->handle_invoke) { |
| VERIFY(AEE_SUCCESS == (nErr = open_mod_handle_open(dm, uri, &dm->h64))); |
| } |
| RW_MUTEX_LOCK_WRITE(me->mut); |
| do { |
| HASH_FIND_INT(me->openMods, &dm->key, dmOld); |
| if(dmOld) { |
| dm->key++; |
| } |
| } while(dmOld); |
| RW_MUTEX_LOCK_WRITE(me->smt->mut); |
| HASH_FIND_INT(me->smt->constMods, &dm->key, dmOld); |
| RW_MUTEX_UNLOCK_WRITE(me->smt->mut); |
| if(dmOld == 0) { |
| HASH_ADD_INT(me->openMods, key, dm); |
| } |
| RW_MUTEX_UNLOCK_WRITE(me->mut); |
| nErr = dmOld != 0 ? -1 : nErr; |
| if(nErr == 0) { |
| *handle = dm->key; |
| } |
| bail: |
| if (nErr != AEE_SUCCESS) { |
| if(dlErr) { |
| const char* dlerr = DLERROR(); |
| if(dlerr != 0){ |
| std_strlcpy(dlStr,dlerr,dlerrorLen); |
| } |
| FARF(HIGH, "dlerror:%x:%s", dlErr, dlerr == 0 ? "" : dlerr); |
| nErr = 0; |
| } |
| if(pdlErr) { |
| *pdlErr = dlErr; |
| } |
| if(dm && dm->h64) { |
| (void)open_mod_handle_close(dm, dm->h64); |
| } |
| if(dm && dm->dlhandle) { |
| DLCLOSE(dm->dlhandle); |
| } |
| if(dm) { |
| free(dm); |
| dm = NULL; |
| } |
| VERIFY_EPRINTF("Error %x: open modtable dynamic failed. dlerr %x\n", nErr, dlErr); |
| } |
| FARF(HIGH, "done open_mod_table_open_dynamic for %s rv %x handle: %p %x", uri, nErr, *handle, dlErr); |
| if(tmp) { |
| free(tmp); |
| tmp = NULL; |
| } |
| return nErr; |
| } |
| |
| static int open_mod_table_open_from_static(struct open_mod_table* me, |
| struct static_mod** tbl, |
| const char* uri, |
| remote_handle* handle) |
| { |
| int nErr = AEE_SUCCESS; |
| struct static_mod *sm = 0; |
| struct open_mod *dm = 0, *dmOld = 0; |
| int len = std_strlen(uri); |
| int sz = len*2 + sizeof("file:///lib_skel.so?_skel_handle_invoke&_modver=1.0") + 1; |
| char *tmp = 0; |
| VERIFYC(NULL != (dm = ((struct open_mod*)calloc(1, sizeof(*dm) + sz))), AEE_ENOMEMORY); |
| RW_MUTEX_LOCK_READ(me->mut); |
| HASH_FIND_STR(*tbl, uri, sm); |
| RW_MUTEX_UNLOCK_READ(me->mut); |
| std_memmove(dm->uri, uri, len); |
| if(sm == 0) { |
| VERIFY(AEE_SUCCESS == (nErr = parse_uri(uri, len, &dm->vals))); |
| FARF(HIGH, "file %.*s %d", dm->vals.filelen, dm->vals.file, dm->vals.filelen); |
| FARF(HIGH, "sym %.*s %d", dm->vals.symlen, dm->vals.sym, dm->vals.symlen); |
| FARF(HIGH, "version %.*s %d", dm->vals.verlen, dm->vals.ver, dm->vals.verlen); |
| if(dm->vals.verlen) { |
| int rv = std_snprintf(dm->uri, sz, "file:///%.*s?%.*s&_modver=%.*s", |
| dm->vals.filelen, dm->vals.file, |
| dm->vals.symlen, dm->vals.sym, |
| dm->vals.verlen, dm->vals.ver); |
| VERIFYC(sz >= rv, AEE_EBADSIZE); |
| } else { |
| int rv = std_snprintf(dm->uri, sz, "file://%.*s?%.*s", |
| dm->vals.filelen, dm->vals.file, |
| dm->vals.symlen, dm->vals.sym); |
| VERIFYC(sz >= rv, AEE_EBADSIZE); |
| } |
| FARF(HIGH, "dm->uri:%s", dm->uri); |
| |
| RW_MUTEX_LOCK_READ(me->mut); |
| HASH_FIND_STR(*tbl, dm->uri, sm); |
| RW_MUTEX_UNLOCK_READ(me->mut); |
| } |
| VERIFYC(0 != sm, AEE_ENOTINITIALIZED); |
| assert(sm->handle_invoke || sm->invoke); |
| dm->handle_invoke = sm->handle_invoke; |
| dm->invoke = sm->invoke; |
| dm->key = (uint32)(uintptr_t)dm; |
| dm->refs = 1; |
| if(dm->handle_invoke) { |
| VERIFY(AEE_SUCCESS == (nErr = open_mod_handle_open(dm, uri, &dm->h64))); |
| } |
| |
| RW_MUTEX_LOCK_WRITE(me->mut); |
| do { |
| HASH_FIND_INT(me->openMods, &dm->key, dmOld); |
| if(dmOld) { |
| dm->key++; |
| } |
| } while(dmOld); |
| HASH_ADD_INT(me->openMods, key, dm); |
| RW_MUTEX_UNLOCK_WRITE(me->mut); |
| |
| *handle = dm->key; |
| bail: |
| if(tmp) { |
| free(tmp); |
| tmp = NULL; |
| } |
| if(nErr != AEE_SUCCESS) { |
| VERIFY_EPRINTF("Error %x: modtable open from static failed.\n", nErr); |
| } |
| if(nErr && dm) { |
| if(dm->h64) { |
| (void)open_mod_handle_close(dm, dm->h64); |
| } |
| free(dm); |
| dm = NULL; |
| } |
| return nErr; |
| } |
| |
| static int open_mod_table_open(struct open_mod_table* me, const char* uri, remote_handle* handle, char* dlerr, int dlerrorLen, int* pdlErr) |
| { |
| int nErr = AEE_SUCCESS, dlErr = 0; |
| if(pdlErr) { |
| *pdlErr = 0; |
| } |
| if(0 != open_mod_table_open_static_override(me, uri, handle)) { |
| VERIFY(AEE_SUCCESS == (nErr = open_mod_table_open_dynamic(me, uri, handle, dlerr, dlerrorLen, &dlErr))); |
| if(dlErr != 0) { |
| FARF(HIGH, "dynammic open failed, trying static"); |
| if(0 != open_mod_table_open_static(me, uri, handle)) { |
| if(pdlErr) { |
| *pdlErr = dlErr; |
| } |
| } |
| } |
| } |
| bail: |
| FARF(HIGH, "done open for %s rv %d handle: %p", uri, nErr, *handle); |
| if(nErr != AEE_SUCCESS) { |
| VERIFY_EPRINTF("Error %x: open modtable failed\n", nErr); |
| } |
| return nErr; |
| } |
| |
| static void open_mod_close(struct open_mod_table *me, struct open_mod* dm) { |
| RW_MUTEX_LOCK_WRITE(me->mut); |
| dm->refs--; |
| if(dm->refs <= 0) { |
| HASH_DEL(me->openMods,dm); |
| } else { |
| dm = 0; |
| } |
| RW_MUTEX_UNLOCK_WRITE(me->mut); |
| if(dm) { |
| if(dm->h64) { |
| (void)open_mod_handle_close(dm, dm->h64); |
| } |
| if(dm->dlhandle) { |
| DLCLOSE(dm->dlhandle); |
| } |
| free(dm); |
| dm = NULL; |
| } |
| } |
| static int open_mod_table_close(struct open_mod_table* me, remote_handle64 handle, char* errStr, int errStrLen, int* pdlErr) |
| { |
| int nErr = AEE_SUCCESS; |
| struct open_mod *dm, *del = 0;; |
| int dlErr = 0; |
| // First ensure that the handle is valid |
| RW_MUTEX_LOCK_WRITE(me->mut); |
| HASH_FIND_INT(me->openMods, &handle, dm); |
| if(dm) { |
| dm->refs--; |
| if(dm->refs <= 0) { |
| del = dm; |
| FARF(HIGH, "deleting %s %p", del->uri, del); |
| HASH_DEL(me->openMods,dm); |
| } else { |
| FARF(HIGH, "leaked %s", dm->uri); |
| dm = 0; |
| } |
| } |
| RW_MUTEX_UNLOCK_WRITE(me->mut); |
| if(del) { |
| if(del->h64) { |
| (void)open_mod_handle_close(dm, dm->h64); |
| } |
| if(del->dlhandle) { |
| dlErr = DLCLOSE(del->dlhandle); |
| } |
| FARF(HIGH, "free %s %p", del->uri, del); |
| free(del); |
| del = NULL; |
| } |
| VERIFY(del); |
| |
| bail: |
| if(dlErr) { |
| const char* error = DLERROR(); |
| nErr = dlErr; |
| if(error != 0){ |
| std_strlcpy(errStr,error,errStrLen); |
| } |
| VERIFY_EPRINTF("Error %x: open modtable close failed. dlerr %s\n", nErr, error); |
| } |
| if(pdlErr) { |
| *pdlErr = dlErr; |
| } |
| return nErr; |
| } |
| |
| static struct open_mod* open_mod_table_get_open(struct open_mod_table* me, remote_handle handle) { |
| struct open_mod* om = 0; |
| RW_MUTEX_LOCK_READ(me->mut); |
| HASH_FIND_INT(me->openMods, &handle, om); |
| if(0 != om) { |
| om->refs++; |
| } |
| RW_MUTEX_UNLOCK_READ(me->mut); |
| return om; |
| } |
| static struct const_mod* open_mod_table_get_const(struct open_mod_table* me, remote_handle handle) { |
| struct const_mod* cm = 0; |
| RW_MUTEX_LOCK_READ(me->smt->mut); |
| HASH_FIND_INT(me->smt->constMods, &handle, cm); |
| RW_MUTEX_UNLOCK_READ(me->smt->mut); |
| return cm; |
| } |
| |
| static int open_mod_table_handle_invoke(struct open_mod_table* me, remote_handle handle, uint32 sc, remote_arg* pra) { |
| int nErr = AEE_SUCCESS; |
| struct open_mod* om = 0; |
| struct const_mod* cm = 0; |
| remote_handle64 h = 0; |
| invoke_fn invoke = 0; |
| handle_invoke_fn handle_invoke = 0; |
| cm = open_mod_table_get_const(me, handle); |
| if(cm) { |
| invoke = cm->invoke; |
| handle_invoke = cm->handle_invoke; |
| h = cm->h64; |
| } else { |
| VERIFYC(0 != (om = open_mod_table_get_open(me, handle)), AEE_ENOSUCHMOD); |
| invoke = om->invoke; |
| handle_invoke = om->handle_invoke; |
| h = om->h64; |
| } |
| if(invoke) { |
| VERIFY(AEE_SUCCESS == (nErr = invoke(sc, pra))); |
| } else { |
| VERIFY(AEE_SUCCESS == (nErr = handle_invoke(h, sc, pra))); |
| } |
| bail: |
| if(om) { |
| open_mod_close(me, om); |
| } |
| FARF(HIGH, "invoke rv %p %x %x", handle, sc, nErr); |
| return nErr; |
| } |
| |
| struct mod_table { |
| struct static_mod_table smt; |
| struct open_mod_table omt; |
| }; |
| |
| // mod_table object |
| static struct static_mod_table static_mod_table_obj; |
| |
| |
| /** |
| * register a static component for invocations |
| * this can be called at any time including from a static constructor |
| * |
| * overrides will be tried first, then dynamic modules, then regular |
| * static modules. |
| * |
| * name, name of the interface to register |
| * pfn, function pointer to the skel invoke function |
| * |
| * for example: |
| * __attribute__((constructor)) static void my_module_ctor(void) { |
| * mod_table_register_static("my_module", my_module_skel_invoke); |
| * } |
| * |
| */ |
| int mod_table_register_static_override(const char* name, int(*pfn)(uint32 sc, remote_arg* pra)) { |
| if(0 == static_mod_table_ctor(&static_mod_table_obj)) { |
| return static_mod_table_register_static_override(&static_mod_table_obj, name, pfn); |
| } |
| return AEE_EUNKNOWN; |
| } |
| |
| int mod_table_register_static_override1(const char* name, int(*pfn)(remote_handle64, uint32 sc, remote_arg* pra)) { |
| if(0 == static_mod_table_ctor(&static_mod_table_obj)) { |
| return static_mod_table_register_static_override1(&static_mod_table_obj, name, pfn); |
| } |
| return AEE_EUNKNOWN; |
| } |
| |
| |
| /** |
| * register a static component for invocations |
| * this can be called at any time including from a static constructor |
| * |
| * name, name of the interface to register |
| * pfn, function pointer to the skel invoke function |
| * |
| * for example: |
| * __attribute__((constructor)) static void my_module_ctor(void) { |
| * mod_table_register_static("my_module", my_module_skel_invoke); |
| * } |
| * |
| */ |
| int mod_table_register_static(const char* name, int(*pfn)(uint32 sc, remote_arg* pra)) { |
| if(0 == static_mod_table_ctor(&static_mod_table_obj)) { |
| return static_mod_table_register_static(&static_mod_table_obj, name, pfn); |
| } |
| return AEE_EUNKNOWN; |
| } |
| |
| int mod_table_register_static1(const char* name, int(*pfn)(remote_handle64, uint32 sc, remote_arg* pra)) { |
| if(0 == static_mod_table_ctor(&static_mod_table_obj)) { |
| return static_mod_table_register_static1(&static_mod_table_obj, name, pfn); |
| } |
| return AEE_EUNKNOWN; |
| } |
| |
| |
| /** |
| * Open a module and get a handle to it |
| * |
| * uri, name of module to open |
| * handle, Output handle |
| * dlerr, Error String (if an error occurs) |
| * dlerrorLen, Length of error String (if an error occurs) |
| * pdlErr, Error identifier |
| */ |
| int mod_table_open(const char* uri, remote_handle* handle, char* dlerr, int dlerrorLen, int* pdlErr) { |
| int nErr = AEE_SUCCESS; |
| struct open_mod_table* pomt = 0; |
| FARF(HIGH, "mod_table_open for %s", uri); |
| VERIFY(AEE_SUCCESS == (nErr = HAP_pls_add_lookup((uintptr_t)open_mod_table_ctor_imp, 0, sizeof(*pomt), open_mod_table_ctor_imp, (void*)&static_mod_table_obj, open_mod_table_dtor_imp, (void**)&pomt))); |
| VERIFY(AEE_SUCCESS == (nErr = open_mod_table_open(pomt,uri,handle,dlerr,dlerrorLen,pdlErr))); |
| bail: |
| FARF(HIGH, "mod_table_open for %s nErr: %x", uri, nErr); |
| if(nErr != AEE_SUCCESS) { |
| VERIFY_EPRINTF("Error %x: modtable open failed\n", nErr); |
| } |
| return nErr; |
| } |
| /** |
| * invoke a handle in the mod table |
| * |
| * handle, handle to invoke |
| * sc, scalars, see remote.h for documentation. |
| * pra, args, see remote.h for documentation. |
| */ |
| int mod_table_invoke(remote_handle handle, uint32 sc, remote_arg* pra) { |
| int nErr = AEE_SUCCESS; |
| struct open_mod_table* pomt = 0; |
| VERIFY(AEE_SUCCESS == (nErr = HAP_pls_add_lookup((uintptr_t)open_mod_table_ctor_imp, 0, sizeof(*pomt), open_mod_table_ctor_imp, (void*)&static_mod_table_obj, open_mod_table_dtor_imp, (void**)&pomt))); |
| VERIFY(AEE_SUCCESS == (nErr = open_mod_table_handle_invoke(pomt, handle, sc, pra))); |
| bail: |
| return nErr; |
| } |
| |
| /** |
| * Closes a handle in the mod table |
| * |
| * handle, handle to close |
| * errStr, Error String (if an error occurs) |
| * errStrLen, Length of error String (if an error occurs) |
| * pdlErr, Error identifier |
| */ |
| int mod_table_close(remote_handle handle, char* errStr, int errStrLen, int* pdlErr) { |
| int nErr = AEE_SUCCESS; |
| struct open_mod_table* pomt = 0; |
| VERIFY(AEE_SUCCESS == (nErr = HAP_pls_lookup((uintptr_t)open_mod_table_ctor_imp, 0, (void**)&pomt))); |
| VERIFY(AEE_SUCCESS == (nErr = open_mod_table_close(pomt, handle, errStr,errStrLen,pdlErr))); |
| bail: |
| if(nErr != AEE_SUCCESS) { |
| VERIFY_EPRINTF("Error %x: modtable close failed\n", nErr); |
| } |
| return nErr; |
| } |
| |
| /** |
| * internal use only |
| */ |
| int mod_table_register_const_handle(remote_handle remote, const char* uri, int(*pfn)(uint32 sc, remote_arg* pra)) { |
| if(0 == static_mod_table_ctor(&static_mod_table_obj)) { |
| return static_mod_table_register_const_handle(&static_mod_table_obj, remote, 0, uri, pfn, 0); |
| } |
| return AEE_EUNKNOWN; |
| } |
| int mod_table_register_const_handle1(remote_handle remote, remote_handle64 local, const char* uri, int(*pfn)(remote_handle64, uint32 sc, remote_arg* pra)) { |
| if(0 == static_mod_table_ctor(&static_mod_table_obj)) { |
| return static_mod_table_register_const_handle(&static_mod_table_obj, remote, local, uri, 0, pfn); |
| } |
| return AEE_EUNKNOWN; |
| } |
| |
| // Constructor and destructor |
| static int mod_table_ctor(void) { |
| return static_mod_table_ctor(&static_mod_table_obj); |
| } |
| static void mod_table_dtor(void) { |
| static_mod_table_dtor_imp(&static_mod_table_obj); |
| return; |
| } |
| |
| PL_DEFINE(mod_table, mod_table_ctor, mod_table_dtor); |
