\r
#include "dahelper.h"\r
\r
+char *lib_string[NUM_ORIGINAL_LIBRARY] = {"libc.so.6", "libpthread.so.0", \r
+ "libelementary.so", "libosp-uifw.so", "libosp-appfw.so", "libosp-web.so", \r
+ "libecore_input_evas.so.1", "libdaemon.so.0", "libcapi-appfw-application.so.0"};\r
+void *lib_handle[NUM_ORIGINAL_LIBRARY];\r
+\r
/* trace info global variable */\r
__traceInfo gTraceInfo =\r
{\r
// return 0 if caller is user binary, otherwise return 1
static int determineCaller(char* tracestring)
{
- char *apppath, *substr;
+ char *substr;
// determine whether saveptr (caller binary name) is user binary or not
-// apppath = getenv("APP_PATH");
- apppath = NULL;
-
- if(apppath == NULL)
- substr = strstr(tracestring, APP_INSTALL_PATH);
- else
- substr = strstr(tracestring, apppath);
+ substr = strstr(tracestring, APP_INSTALL_PATH);
if(substr == NULL) // not user binary
return 1;
void __attribute__((destructor)) _fini_probe()
{
+ int i;
TRACE_STATE_SET(TS_FINIT);
gTraceInfo.init_complete = -1;
finalize_hash_table();
+ for(i = 0; i < NUM_ORIGINAL_LIBRARY; i++)
+ {
+ if(lib_handle[i] != NULL)
+ {
+ dlclose(lib_handle[i]);
+ }
+ }
+
TRACE_STATE_UNSET(TS_FINIT);
}
return true;
}
-// update heap memory size though socket
-// return 0 if size is updated though socket
+// update heap memory size through socket
+// return 0 if size is updated through socket
// return 1 if size is updated into global variable
int update_heap_memory_size(bool isAdd, size_t size)
{
} \
} while(0)
+#define NUM_ORIGINAL_LIBRARY 9
+
+typedef enum
+{
+ LIBC = 0,
+ LIBPTHREAD = 1,
+ LIBELEMENTARY = 2,
+ LIBOSP_UIFW = 3,
+ LIBOSP_APPFW = 4,
+ LIBOSP_WEB = 5,
+ LIBECORE_INPUT_EVAS = 6,
+ LIBDAEMON = 7,
+ LIBCAPI_APPFW_APPLICATION = 8
+} ORIGINAL_LIBRARY;
+
+extern char *lib_string[NUM_ORIGINAL_LIBRARY];
+extern void *lib_handle[NUM_ORIGINAL_LIBRARY];
+
// type definition for global variable
typedef struct
{
#define NUM_OF_MONITOR 3
#define DA_LOG_MAX 4096
+#define PERROR_MSG_MAX 128
#define DEFAULT_TOKEN "`,"
do { \
if(!FUNCTIONPOINTER) { \
probeBlockStart(); \
- void* lib_handle = dlopen(#SONAME, RTLD_LAZY); \
- if(lib_handle == NULL) { \
- perror("dlopen failed : " #SONAME ); \
- exit(0); \
+ if(lib_handle[SONAME] == NULL) { \
+ lib_handle[SONAME] = dlopen(lib_string[SONAME], RTLD_LAZY); \
+ if(lib_handle[SONAME] == NULL) { \
+ char perror_msg[PERROR_MSG_MAX]; \
+ sprintf(perror_msg, "dlopen failed : %s", lib_string[SONAME]); \
+ perror(perror_msg); \
+ exit(0); \
+ } \
} \
- FUNCTIONPOINTER = dlsym(lib_handle, #FUNCNAME); \
+ FUNCTIONPOINTER = dlsym(lib_handle[SONAME], #FUNCNAME); \
if(FUNCTIONPOINTER == NULL || dlerror() != NULL) { \
perror("dlsym failed : " #FUNCNAME); \
exit(0); \
do { \
if(!FUNCTIONPOINTER) { \
probeBlockStart(); \
- void* lib_handle = dlopen(#LIBNAME, RTLD_LAZY); \
- if(lib_handle == NULL) { \
- perror("dlopen failed : " #LIBNAME ); \
- exit(0); \
+ if(lib_handle[LIBNAME] == NULL) { \
+ lib_handle[LIBNAME] = dlopen(lib_string[LIBNAME], RTLD_LAZY); \
+ if(lib_handle[LIBNAME] == NULL) { \
+ char perror_msg[PERROR_MSG_MAX]; \
+ sprintf(perror_msg, "dlopen failed : %s", lib_string[LIBNAME]); \
+ perror(perror_msg); \
+ exit(0); \
+ } \
} \
- void* funcp = dlsym(lib_handle, #FUNCNAME); \
+ void* funcp = dlsym(lib_handle[LIBNAME], #FUNCNAME); \
if(funcp == NULL || dlerror() != NULL) { \
perror("dlsym failed : " #FUNCNAME); \
exit(0); \
exit(0);
}
- memcpy(&Constructp, &tmpPtr, sizeof(&tmpPtr));
+ memcpy(&Constructp, &tmpPtr, sizeof(tmpPtr));
probeBlockEnd();
}
exit(0);
}
- memcpy(&Constructp, &tmpPtr, sizeof(&tmpPtr));
+ memcpy(&Constructp, &tmpPtr, sizeof(tmpPtr));
probeBlockEnd();
}
exit(0);
}
- memcpy(&Constructp, &tmpPtr, sizeof(&tmpPtr));
+ memcpy(&Constructp, &tmpPtr, sizeof(tmpPtr));
probeBlockEnd();
}
exit(0);
}
- memcpy(&Constructp, &tmpPtr, sizeof(&tmpPtr));
+ memcpy(&Constructp, &tmpPtr, sizeof(tmpPtr));
probeBlockEnd();
}
exit(0);
}
- memcpy(&Constructp, &tmpPtr, sizeof(&tmpPtr));
+ memcpy(&Constructp, &tmpPtr, sizeof(tmpPtr));
probeBlockEnd();
}
exit(0);
}
- memcpy(&Constructp, &tmpPtr, sizeof(&tmpPtr));
+ memcpy(&Constructp, &tmpPtr, sizeof(tmpPtr));
probeBlockEnd();
}
exit(0);
}
- memcpy(&Constructp, &tmpPtr, sizeof(&tmpPtr));
+ memcpy(&Constructp, &tmpPtr, sizeof(tmpPtr));
probeBlockEnd();
}
exit(0);
}
- memcpy(&Flushp, &tmpPtr, sizeof(&tmpPtr));
+ memcpy(&Flushp, &tmpPtr, sizeof(tmpPtr));
probeBlockEnd();
}
exit(0);
}
- memcpy(&GetNamep, &tmpPtr, sizeof(&tmpPtr));
+ memcpy(&GetNamep, &tmpPtr, sizeof(tmpPtr));
probeBlockEnd();
}
exit(0);
}
- memcpy(&Readp, &tmpPtr, sizeof(&tmpPtr));
+ memcpy(&Readp, &tmpPtr, sizeof(tmpPtr));
probeBlockEnd();
}
exit(0);
}
- memcpy(&Readp, &tmpPtr, sizeof(&tmpPtr));
+ memcpy(&Readp, &tmpPtr, sizeof(tmpPtr));
probeBlockEnd();
}
exit(0);
}
- memcpy(&Readp, &tmpPtr, sizeof(&tmpPtr));
+ memcpy(&Readp, &tmpPtr, sizeof(tmpPtr));
probeBlockEnd();
}
exit(0);
}
- memcpy(&Seekp, &tmpPtr, sizeof(&tmpPtr));
+ memcpy(&Seekp, &tmpPtr, sizeof(tmpPtr));
probeBlockEnd();
}
exit(0);
}
- memcpy(&Tellp, &tmpPtr, sizeof(&tmpPtr));
+ memcpy(&Tellp, &tmpPtr, sizeof(tmpPtr));
probeBlockEnd();
}
exit(0);
}
- memcpy(&Truncatep, &tmpPtr, sizeof(&tmpPtr));
+ memcpy(&Truncatep, &tmpPtr, sizeof(tmpPtr));
probeBlockEnd();
}
exit(0);
}
- memcpy(&Writep, &tmpPtr, sizeof(&tmpPtr));
+ memcpy(&Writep, &tmpPtr, sizeof(tmpPtr));
probeBlockEnd();
}
exit(0);
}
- memcpy(&Writep, &tmpPtr, sizeof(&tmpPtr));
+ memcpy(&Writep, &tmpPtr, sizeof(tmpPtr));
probeBlockEnd();
}
exit(0);
}
- memcpy(&Writep, &tmpPtr, sizeof(&tmpPtr));
+ memcpy(&Writep, &tmpPtr, sizeof(tmpPtr));
probeBlockEnd();
}
exit(0);
}
- memcpy(&FileDp, &tmpPtr, sizeof(&tmpPtr));
+ memcpy(&FileDp, &tmpPtr, sizeof(tmpPtr));
probeBlockEnd();
}
// exit(0);
// }
//
-// memcpy(&GetFileNamep, &tmpPtr, sizeof(&tmpPtr));
+// memcpy(&GetFileNamep, &tmpPtr, sizeof(tmpPtr));
// probeBlockEnd();
// }
// ret = (File::(*GetFileNamep))(filePath);
result ret;
GET_REAL_FUNC_OSP(_ZN5Tizen3App5UiApp7ExecuteEPFPS1_vEPKNS_4Base10Collection5IListE,
- libosp-uifw.so, uiapp_executep);
+ LIBOSP_UIFW, uiapp_executep);
probeBlockStart();
LIFECYCLE_PROBE_BLOCK("INITIALIZING");
static methodType appimpl_onterminatep;
DECLARE_COMMON_VARIABLE;
- GET_REAL_FUNC_OSP(_ZN5Tizen3App8_AppImpl11OnTerminateEPv, libosp-appfw.so, appimpl_onterminatep);
+ GET_REAL_FUNC_OSP(_ZN5Tizen3App8_AppImpl11OnTerminateEPv, LIBOSP_APPFW, appimpl_onterminatep);
probeBlockStart();
LIFECYCLE_PROBE_BLOCK("TERMINATING");
static methodType appimpl_ondeviceorientationchangedp;
GET_REAL_FUNC_OSP(_ZN5Tizen3App8_AppImpl26OnDeviceOrientationChangedE24app_device_orientation_ePv,
- libosp-appfw.so, appimpl_ondeviceorientationchangedp);
+ LIBOSP_APPFW, appimpl_ondeviceorientationchangedp);
probeBlockStart();
on_orientation_changed((int)orientation, false);
static methodType appinfo_setappstatep;
DECLARE_COMMON_VARIABLE;
- GET_REAL_FUNC_OSP(_ZN5Tizen3App8_AppInfo11SetAppStateENS0_8AppStateE, libosp-appfw.so, appinfo_setappstatep);
+ GET_REAL_FUNC_OSP(_ZN5Tizen3App8_AppInfo11SetAppStateENS0_8AppStateE, LIBOSP_APPFW, appinfo_setappstatep);
probeBlockStart();
if(appState == RUNNING)
static methodType uiappimpl_onbackgroundp;
DECLARE_COMMON_VARIABLE;
- GET_REAL_FUNC_OSP(_ZN5Tizen3App10_UiAppImpl12OnBackgroundEv, libosp-uifw.so, uiappimpl_onbackgroundp);
+ GET_REAL_FUNC_OSP(_ZN5Tizen3App10_UiAppImpl12OnBackgroundEv, LIBOSP_UIFW, uiappimpl_onbackgroundp);
probeBlockStart();
SCREENSHOT_LOCK();
static methodType uiappimpl_onforegroundp;
DECLARE_COMMON_VARIABLE;
- GET_REAL_FUNC_OSP(_ZN5Tizen3App10_UiAppImpl12OnForegroundEv, libosp-uifw.so, uiappimpl_onforegroundp);
+ GET_REAL_FUNC_OSP(_ZN5Tizen3App10_UiAppImpl12OnForegroundEv, LIBOSP_UIFW, uiappimpl_onforegroundp);
probeBlockStart();
LIFECYCLE_PROBE_BLOCK("RUNNING");
static methodType uiappimpl_ondeviceorientationchangedp;
GET_REAL_FUNC_OSP(_ZThn4_N5Tizen3App10_UiAppImpl26OnDeviceOrientationChangedE24app_device_orientation_e,
- libosp-uifw.so, uiappimpl_ondeviceorientationchangedp);
+ LIBOSP_UIFW, uiappimpl_ondeviceorientationchangedp);
probeBlockStart();
on_orientation_changed((int)orientation, false);
if (!Createp) {
probeBlockStart();
- void* lib_handle = dlopen("libosp-appfw.so", RTLD_LAZY);
- if (lib_handle == NULL) {
- perror("dlopen failed : libosp-appfw.so");
- exit(0);
+ if(lib_handle[LIBOSP_APPFW] == NULL) {
+ lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
+ if (lib_handle[LIBOSP_APPFW] == NULL) {
+ perror("dlopen failed : libosp-appfw.so");
+ exit(0);
+ }
}
- tmpPtr = dlsym(lib_handle, "_ZN5Tizen4Base7Runtime5Mutex6CreateEv");
+ tmpPtr = dlsym(lib_handle[LIBOSP_APPFW], "_ZN5Tizen4Base7Runtime5Mutex6CreateEv");
if (tmpPtr == NULL || dlerror() != NULL) {
perror("dlsym failed : Tizen::Base::Runtime::Mutex::Create");
exit(0);
}
- memcpy(&Createp, &tmpPtr, sizeof(&tmpPtr));
+ memcpy(&Createp, &tmpPtr, sizeof(tmpPtr));
probeBlockEnd();
}
if (!Createp) {
probeBlockStart();
- void* lib_handle = dlopen("libosp-appfw.so", RTLD_LAZY);
- if (lib_handle == NULL) {
- perror("dlopen failed : libosp-appfw.so");
- exit(0);
+ if(lib_handle[LIBOSP_APPFW] == NULL) {
+ lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
+ if (lib_handle[LIBOSP_APPFW] == NULL) {
+ perror("dlopen failed : libosp-appfw.so");
+ exit(0);
+ }
}
- tmpPtr = dlsym(lib_handle, "_ZN5Tizen4Base7Runtime5Mutex6CreateERKNS0_6StringE");
+ tmpPtr = dlsym(lib_handle[LIBOSP_APPFW], "_ZN5Tizen4Base7Runtime5Mutex6CreateERKNS0_6StringE");
if (tmpPtr == NULL || dlerror() != NULL) {
perror("dlsym failed : Tizen::Base::Runtime::Mutex::Create");
exit(0);
}
- memcpy(&Createp, &tmpPtr, sizeof(&tmpPtr));
+ memcpy(&Createp, &tmpPtr, sizeof(tmpPtr));
probeBlockEnd();
}
if (!Releasep) {
probeBlockStart();
- void* lib_handle = dlopen("libosp-appfw.so", RTLD_LAZY);
- if (lib_handle == NULL) {
- perror("dlopen failed : libosp-appfw.so");
- exit(0);
+ if(lib_handle[LIBOSP_APPFW] == NULL) {
+ lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
+ if (lib_handle[LIBOSP_APPFW] == NULL) {
+ perror("dlopen failed : libosp-appfw.so");
+ exit(0);
+ }
}
- tmpPtr = dlsym(lib_handle, "_ZN5Tizen4Base7Runtime5Mutex7ReleaseEv");
+ tmpPtr = dlsym(lib_handle[LIBOSP_APPFW], "_ZN5Tizen4Base7Runtime5Mutex7ReleaseEv");
if (tmpPtr == NULL || dlerror() != NULL) {
perror("dlsym failed : Tizen::Base::Runtime::Mutex::Release");
exit(0);
}
- memcpy(&Releasep, &tmpPtr, sizeof(&tmpPtr));
+ memcpy(&Releasep, &tmpPtr, sizeof(tmpPtr));
probeBlockEnd();
}
if (!Acquirep) {
probeBlockStart();
- void* lib_handle = dlopen("libosp-appfw.so", RTLD_LAZY);
- if (lib_handle == NULL) {
- perror("dlopen failed : libosp-appfw.so");
- exit(0);
+ if(lib_handle[LIBOSP_APPFW] == NULL) {
+ lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
+ if (lib_handle[LIBOSP_APPFW] == NULL) {
+ perror("dlopen failed : libosp-appfw.so");
+ exit(0);
+ }
}
- tmpPtr = dlsym(lib_handle, "_ZN5Tizen4Base7Runtime5Mutex7AcquireEv");
+ tmpPtr = dlsym(lib_handle[LIBOSP_APPFW], "_ZN5Tizen4Base7Runtime5Mutex7AcquireEv");
if (tmpPtr == NULL || dlerror() != NULL) {
perror("dlsym failed : Tizen::Base::Runtime::Mutex::Acquire");
exit(0);
}
- memcpy(&Acquirep, &tmpPtr, sizeof(&tmpPtr));
+ memcpy(&Acquirep, &tmpPtr, sizeof(tmpPtr));
probeBlockEnd();
}
if (!TryToAcquirep) {
probeBlockStart();
- void* lib_handle = dlopen("libosp-appfw.so", RTLD_LAZY);
- if (lib_handle == NULL) {
- perror("dlopen failed : libosp-appfw.so");
- exit(0);
+ if(lib_handle[LIBOSP_APPFW] == NULL) {
+ lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
+ if (lib_handle[LIBOSP_APPFW] == NULL) {
+ perror("dlopen failed : libosp-appfw.so");
+ exit(0);
+ }
}
- tmpPtr = dlsym(lib_handle, "_ZN5Tizen4Base7Runtime5Mutex12TryToAcquireEv");
+ tmpPtr = dlsym(lib_handle[LIBOSP_APPFW], "_ZN5Tizen4Base7Runtime5Mutex12TryToAcquireEv");
if (tmpPtr == NULL || dlerror() != NULL) {
perror("dlsym failed : Tizen::Base::Runtime::Mutex::TryToAcquire");
exit(0);
}
- memcpy(&TryToAcquirep, &tmpPtr, sizeof(&tmpPtr));
+ memcpy(&TryToAcquirep, &tmpPtr, sizeof(tmpPtr));
probeBlockEnd();
}
if (!Createp) {
probeBlockStart();
- void* lib_handle = dlopen("libosp-appfw.so", RTLD_LAZY);
- if (lib_handle == NULL) {
- perror("dlopen failed : libosp-appfw.so");
- exit(0);
+ if(lib_handle[LIBOSP_APPFW] == NULL) {
+ lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
+ if (lib_handle[LIBOSP_APPFW] == NULL) {
+ perror("dlopen failed : libosp-appfw.so");
+ exit(0);
+ }
}
- tmpPtr = dlsym(lib_handle, "_ZN5Tizen4Base7Runtime9Semaphore6CreateEi");
+ tmpPtr = dlsym(lib_handle[LIBOSP_APPFW], "_ZN5Tizen4Base7Runtime9Semaphore6CreateEi");
if (tmpPtr == NULL || dlerror() != NULL) {
perror("dlsym failed : Tizen::Base::Runtime::Semaphore::Create");
exit(0);
}
- memcpy(&Createp, &tmpPtr, sizeof(&tmpPtr));
+ memcpy(&Createp, &tmpPtr, sizeof(tmpPtr));
probeBlockEnd();
}
if (!Createp) {
probeBlockStart();
- void* lib_handle = dlopen("libosp-appfw.so", RTLD_LAZY);
- if (lib_handle == NULL) {
- perror("dlopen failed : libosp-appfw.so");
- exit(0);
+ if(lib_handle[LIBOSP_APPFW] == NULL) {
+ lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
+ if (lib_handle[LIBOSP_APPFW] == NULL) {
+ perror("dlopen failed : libosp-appfw.so");
+ exit(0);
+ }
}
- tmpPtr = dlsym(lib_handle, "_ZN5Tizen4Base7Runtime9Semaphore6CreateERKNS0_6StringEi");
+ tmpPtr = dlsym(lib_handle[LIBOSP_APPFW], "_ZN5Tizen4Base7Runtime9Semaphore6CreateERKNS0_6StringEi");
if (tmpPtr == NULL || dlerror() != NULL) {
perror("dlsym failed : Tizen::Base::Runtime::Semaphore::Create");
exit(0);
}
- memcpy(&Createp, &tmpPtr, sizeof(&tmpPtr));
+ memcpy(&Createp, &tmpPtr, sizeof(tmpPtr));
probeBlockEnd();
}
if (!Acquirep) {
probeBlockStart();
- void* lib_handle = dlopen("libosp-appfw.so", RTLD_LAZY);
- if (lib_handle == NULL) {
- perror("dlopen failed : libosp-appfw.so");
- exit(0);
+ if(lib_handle[LIBOSP_APPFW] == NULL) {
+ lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
+ if (lib_handle[LIBOSP_APPFW] == NULL) {
+ perror("dlopen failed : libosp-appfw.so");
+ exit(0);
+ }
}
- tmpPtr = dlsym(lib_handle, "_ZN5Tizen4Base7Runtime9Semaphore7AcquireEl");
+ tmpPtr = dlsym(lib_handle[LIBOSP_APPFW], "_ZN5Tizen4Base7Runtime9Semaphore7AcquireEl");
if (tmpPtr == NULL || dlerror() != NULL) {
perror("dlsym failed : Tizen::Base::Runtime::Semaphore::Acquire");
exit(0);
}
- memcpy(&Acquirep, &tmpPtr, sizeof(&tmpPtr));
+ memcpy(&Acquirep, &tmpPtr, sizeof(tmpPtr));
probeBlockEnd();
}
if (!TryToAcquirep) {
probeBlockStart();
- void* lib_handle = dlopen("libosp-appfw.so", RTLD_LAZY);
- if (lib_handle == NULL) {
- perror("dlopen failed : libosp-appfw.so");
- exit(0);
+ if(lib_handle[LIBOSP_APPFW] == NULL) {
+ lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
+ if (lib_handle[LIBOSP_APPFW] == NULL) {
+ perror("dlopen failed : libosp-appfw.so");
+ exit(0);
+ }
}
- tmpPtr = dlsym(lib_handle, "_ZN5Tizen4Base7Runtime9Semaphore12TryToAcquireEv");
+ tmpPtr = dlsym(lib_handle[LIBOSP_APPFW], "_ZN5Tizen4Base7Runtime9Semaphore12TryToAcquireEv");
if (tmpPtr == NULL || dlerror() != NULL) {
perror("dlsym failed : Tizen::Base::Runtime::Semaphore::TryToAcquire");
exit(0);
}
- memcpy(&TryToAcquirep, &tmpPtr, sizeof(&tmpPtr));
+ memcpy(&TryToAcquirep, &tmpPtr, sizeof(tmpPtr));
probeBlockEnd();
}
if (!Releasep) {
probeBlockStart();
- void* lib_handle = dlopen("libosp-appfw.so", RTLD_LAZY);
- if (lib_handle == NULL) {
- perror("dlopen failed : libosp-appfw.so");
- exit(0);
+ if(lib_handle[LIBOSP_APPFW] == NULL) {
+ lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
+ if (lib_handle[LIBOSP_APPFW] == NULL) {
+ perror("dlopen failed : libosp-appfw.so");
+ exit(0);
+ }
}
- tmpPtr = dlsym(lib_handle, "_ZN5Tizen4Base7Runtime9Semaphore7ReleaseEv");
+ tmpPtr = dlsym(lib_handle[LIBOSP_APPFW], "_ZN5Tizen4Base7Runtime9Semaphore7ReleaseEv");
if (tmpPtr == NULL || dlerror() != NULL) {
perror("dlsym failed : Tizen::Base::Runtime::Semaphore::Release");
exit(0);
}
- memcpy(&Releasep, &tmpPtr, sizeof(&tmpPtr));
+ memcpy(&Releasep, &tmpPtr, sizeof(tmpPtr));
probeBlockEnd();
}
if (!Constructp) {
probeBlockStart();
- void* lib_handle = dlopen("libosp-appfw.so", RTLD_LAZY);
- if (lib_handle == NULL) {
- perror("dlopen failed : libosp-appfw.so");
- exit(0);
+ if(lib_handle[LIBOSP_APPFW] == NULL) {
+ lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
+ if (lib_handle[LIBOSP_APPFW] == NULL) {
+ perror("dlopen failed : libosp-appfw.so");
+ exit(0);
+ }
}
- tmpPtr = dlsym(lib_handle, "_ZN5Tizen4Base7Runtime7Monitor9ConstructEv");
+ tmpPtr = dlsym(lib_handle[LIBOSP_APPFW], "_ZN5Tizen4Base7Runtime7Monitor9ConstructEv");
if (tmpPtr == NULL || dlerror() != NULL) {
perror("dlsym failed : Tizen::Base::Runtime::Monitor::Construct");
exit(0);
}
- memcpy(&Constructp, &tmpPtr, sizeof(&tmpPtr));
+ memcpy(&Constructp, &tmpPtr, sizeof(tmpPtr));
probeBlockEnd();
}
if (!Enterp) {
probeBlockStart();
- void* lib_handle = dlopen("libosp-appfw.so", RTLD_LAZY);
- if (lib_handle == NULL) {
- perror("dlopen failed : libosp-appfw.so");
- exit(0);
+ if(lib_handle[LIBOSP_APPFW] == NULL) {
+ lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
+ if (lib_handle[LIBOSP_APPFW] == NULL) {
+ perror("dlopen failed : libosp-appfw.so");
+ exit(0);
+ }
}
- tmpPtr = dlsym(lib_handle, "_ZN5Tizen4Base7Runtime7Monitor5EnterEv");
+ tmpPtr = dlsym(lib_handle[LIBOSP_APPFW], "_ZN5Tizen4Base7Runtime7Monitor5EnterEv");
if (tmpPtr == NULL || dlerror() != NULL) {
perror("dlsym failed : Tizen::Base::Runtime::Monitor::Enter");
exit(0);
}
- memcpy(&Enterp, &tmpPtr, sizeof(&tmpPtr));
+ memcpy(&Enterp, &tmpPtr, sizeof(tmpPtr));
probeBlockEnd();
}
if (!Exitp) {
probeBlockStart();
- void* lib_handle = dlopen("libosp-appfw.so", RTLD_LAZY);
- if (lib_handle == NULL) {
- perror("dlopen failed : libosp-appfw.so");
- exit(0);
+ if(lib_handle[LIBOSP_APPFW] == NULL) {
+ lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
+ if (lib_handle[LIBOSP_APPFW] == NULL) {
+ perror("dlopen failed : libosp-appfw.so");
+ exit(0);
+ }
}
- tmpPtr = dlsym(lib_handle, "_ZN5Tizen4Base7Runtime7Monitor4ExitEv");
+ tmpPtr = dlsym(lib_handle[LIBOSP_APPFW], "_ZN5Tizen4Base7Runtime7Monitor4ExitEv");
if (tmpPtr == NULL || dlerror() != NULL) {
perror("dlsym failed : Tizen::Base::Runtime::Monitor::Exit");
exit(0);
}
- memcpy(&Exitp, &tmpPtr, sizeof(&tmpPtr));
+ memcpy(&Exitp, &tmpPtr, sizeof(tmpPtr));
probeBlockEnd();
}
if (!Waitp) {
probeBlockStart();
- void* lib_handle = dlopen("libosp-appfw.so", RTLD_LAZY);
- if (lib_handle == NULL) {
- perror("dlopen failed : libosp-appfw.so");
- exit(0);
+ if(lib_handle[LIBOSP_APPFW] == NULL) {
+ lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
+ if (lib_handle[LIBOSP_APPFW] == NULL) {
+ perror("dlopen failed : libosp-appfw.so");
+ exit(0);
+ }
}
- tmpPtr = dlsym(lib_handle, "_ZN5Tizen4Base7Runtime7Monitor4WaitEv");
+ tmpPtr = dlsym(lib_handle[LIBOSP_APPFW], "_ZN5Tizen4Base7Runtime7Monitor4WaitEv");
if (tmpPtr == NULL || dlerror() != NULL) {
perror("dlsym failed : Tizen::Base::Runtime::Monitor::Wait");
exit(0);
}
- memcpy(&Waitp, &tmpPtr, sizeof(&tmpPtr));
+ memcpy(&Waitp, &tmpPtr, sizeof(tmpPtr));
probeBlockEnd();
}
if (!Notifyp) {
probeBlockStart();
- void* lib_handle = dlopen("libosp-appfw.so", RTLD_LAZY);
- if (lib_handle == NULL) {
- perror("dlopen failed : libosp-appfw.so");
- exit(0);
+ if(lib_handle[LIBOSP_APPFW] == NULL) {
+ lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
+ if (lib_handle[LIBOSP_APPFW] == NULL) {
+ perror("dlopen failed : libosp-appfw.so");
+ exit(0);
+ }
}
- tmpPtr = dlsym(lib_handle, "_ZN5Tizen4Base7Runtime7Monitor6NotifyEv");
+ tmpPtr = dlsym(lib_handle[LIBOSP_APPFW], "_ZN5Tizen4Base7Runtime7Monitor6NotifyEv");
if (tmpPtr == NULL || dlerror() != NULL) {
perror("dlsym failed : Tizen::Base::Runtime::Monitor::Notify");
exit(0);
}
- memcpy(&Notifyp, &tmpPtr, sizeof(&tmpPtr));
+ memcpy(&Notifyp, &tmpPtr, sizeof(tmpPtr));
probeBlockEnd();
}
if (!NotifyAllp) {
probeBlockStart();
- void* lib_handle = dlopen("libosp-appfw.so", RTLD_LAZY);
- if (lib_handle == NULL) {
- perror("dlopen failed : libosp-appfw.so");
- exit(0);
+ if(lib_handle[LIBOSP_APPFW] == NULL) {
+ lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
+ if (lib_handle[LIBOSP_APPFW] == NULL) {
+ perror("dlopen failed : libosp-appfw.so");
+ exit(0);
+ }
}
- tmpPtr = dlsym(lib_handle, "_ZN5Tizen4Base7Runtime7Monitor9NotifyAllEv");
+ tmpPtr = dlsym(lib_handle[LIBOSP_APPFW], "_ZN5Tizen4Base7Runtime7Monitor9NotifyAllEv");
if (tmpPtr == NULL || dlerror() != NULL) {
perror("dlsym failed : Tizen::Base::Runtime::Monitor::NotifyAll");
exit(0);
}
- memcpy(&NotifyAllp, &tmpPtr, sizeof(&tmpPtr));
+ memcpy(&NotifyAllp, &tmpPtr, sizeof(tmpPtr));
probeBlockEnd();
}
// exit(0);
// }
//
-// memcpy(&GetThreadp, &tmpPtr, sizeof(&tmpPtr));
+// memcpy(&GetThreadp, &tmpPtr, sizeof(tmpPtr));
//
// probeBlockEnd();
// }
if (!ThreadProcp) {
probeBlockStart();
- void* lib_handle = dlopen("libosp-appfw.so", RTLD_LAZY);
- if (lib_handle == NULL) {
- perror("dlopen failed : libosp-appfw.so");
- exit(0);
+ if(lib_handle[LIBOSP_APPFW] == NULL) {
+ lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
+ if (lib_handle[LIBOSP_APPFW] == NULL) {
+ perror("dlopen failed : libosp-appfw.so");
+ exit(0);
+ }
}
- tmpPtr = dlsym(lib_handle, "_ZN5Tizen4Base7Runtime11_ThreadImpl10ThreadProcEPv");
+ tmpPtr = dlsym(lib_handle[LIBOSP_APPFW], "_ZN5Tizen4Base7Runtime11_ThreadImpl10ThreadProcEPv");
if (tmpPtr == NULL || dlerror() != NULL) {
perror("dlsym failed : Tizen::Base::Runtime::_ThreadImpl::ThreadProc");
exit(0);
}
- memcpy(&ThreadProcp, &tmpPtr, sizeof(&tmpPtr));
+ memcpy(&ThreadProcp, &tmpPtr, sizeof(tmpPtr));
probeBlockEnd();
}
// exit(0);
// }
//
-// memcpy(&Stopp, &tmpPtr, sizeof(&tmpPtr));
+// memcpy(&Stopp, &tmpPtr, sizeof(tmpPtr));
//
// probeBlockEnd();
// }
// exit(0);
// }
//
-// memcpy(&Finalizep, &tmpPtr, sizeof(&tmpPtr));
+// memcpy(&Finalizep, &tmpPtr, sizeof(tmpPtr));
// probeBlockEnd();
// }
//
// return;
// }
//
-// memcpy(&Threadp, &tmpPtr, sizeof(&tmpPtr));
+// memcpy(&Threadp, &tmpPtr, sizeof(tmpPtr));
// probeBlockEnd();
// }
//
// exit(0);
// }
//
-// memcpy(&ThreadDp, &tmpPtr, sizeof(&tmpPtr));
+// memcpy(&ThreadDp, &tmpPtr, sizeof(tmpPtr));
// probeBlockEnd();
// }
//
if (!Sleepp) {
probeBlockStart();
- void* lib_handle = dlopen("libosp-appfw.so", RTLD_LAZY);
- if (lib_handle == NULL) {
- perror("dlopen failed : libosp-appfw.so");
- exit(0);
+ if(lib_handle[LIBOSP_APPFW] == NULL) {
+ lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
+ if (lib_handle[LIBOSP_APPFW] == NULL) {
+ perror("dlopen failed : libosp-appfw.so");
+ exit(0);
+ }
}
- tmpPtr = dlsym(lib_handle, "_ZN5Tizen4Base7Runtime6Thread5SleepEl");
+ tmpPtr = dlsym(lib_handle[LIBOSP_APPFW], "_ZN5Tizen4Base7Runtime6Thread5SleepEl");
if (tmpPtr == NULL || dlerror() != NULL) {
perror("dlsym failed : Tizen::Base::Runtime::Thread::Sleep");
exit(0);
}
- memcpy(&Sleepp, &tmpPtr, sizeof(&tmpPtr));
+ memcpy(&Sleepp, &tmpPtr, sizeof(tmpPtr));
probeBlockEnd();
}
if (!GetCurrentThreadp) {
probeBlockStart();
- void* lib_handle = dlopen("libosp-appfw.so", RTLD_LAZY);
- if (lib_handle == NULL) {
- perror("dlopen failed : libosp-appfw.so");
- exit(0);
+ if(lib_handle[LIBOSP_APPFW] == NULL) {
+ lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
+ if (lib_handle[LIBOSP_APPFW] == NULL) {
+ perror("dlopen failed : libosp-appfw.so");
+ exit(0);
+ }
}
- tmpPtr = dlsym(lib_handle, "_ZN5Tizen4Base7Runtime6Thread16GetCurrentThreadEv");
+ tmpPtr = dlsym(lib_handle[LIBOSP_APPFW], "_ZN5Tizen4Base7Runtime6Thread16GetCurrentThreadEv");
if (tmpPtr == NULL || dlerror() != NULL) {
perror("dlsym failed : Tizen::Base::Runtime::Thread::GetCurrentThread");
exit(0);
}
- memcpy(&GetCurrentThreadp, &tmpPtr, sizeof(&tmpPtr));
+ memcpy(&GetCurrentThreadp, &tmpPtr, sizeof(tmpPtr));
probeBlockEnd();
}
if (!Yieldp) {
probeBlockStart();
- void* lib_handle = dlopen("libosp-appfw.so", RTLD_LAZY);
- if (lib_handle == NULL) {
- perror("dlopen failed : libosp-appfw.so");
- exit(0);
+ if(lib_handle[LIBOSP_APPFW] == NULL) {
+ lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
+ if (lib_handle[LIBOSP_APPFW] == NULL) {
+ perror("dlopen failed : libosp-appfw.so");
+ exit(0);
+ }
}
- tmpPtr = dlsym(lib_handle, "_ZN5Tizen4Base7Runtime6Thread5YieldEv");
+ tmpPtr = dlsym(lib_handle[LIBOSP_APPFW], "_ZN5Tizen4Base7Runtime6Thread5YieldEv");
if (tmpPtr == NULL || dlerror() != NULL) {
perror("dlsym failed : Tizen::Base::Runtime::Thread::Yield");
exit(0);
}
- memcpy(&Yieldp, &tmpPtr, sizeof(&tmpPtr));
+ memcpy(&Yieldp, &tmpPtr, sizeof(tmpPtr));
probeBlockEnd();
}
if (!Exitp) {
probeBlockStart();
- void* lib_handle = dlopen("libosp-appfw.so", RTLD_LAZY);
- if (lib_handle == NULL) {
- perror("dlopen failed : libosp-appfw.so");
- exit(0);
+ if(lib_handle[LIBOSP_APPFW] == NULL) {
+ lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
+ if (lib_handle[LIBOSP_APPFW] == NULL) {
+ perror("dlopen failed : libosp-appfw.so");
+ exit(0);
+ }
}
- tmpPtr = dlsym(lib_handle, "_ZN5Tizen4Base7Runtime6Thread4ExitEi");
+ tmpPtr = dlsym(lib_handle[LIBOSP_APPFW], "_ZN5Tizen4Base7Runtime6Thread4ExitEi");
if (tmpPtr == NULL || dlerror() != NULL) {
perror("dlsym failed : Tizen::Base::Runtime::Thread::Exit");
exit(0);
}
- memcpy(&Exitp, &tmpPtr, sizeof(&tmpPtr));
+ memcpy(&Exitp, &tmpPtr, sizeof(tmpPtr));
probeBlockEnd();
}
if (!Constructp) {
probeBlockStart();
- void* lib_handle = dlopen("libosp-appfw.so", RTLD_LAZY);
- if (lib_handle == NULL) {
- perror("dlopen failed : libosp-appfw.so");
- exit(0);
+ if(lib_handle[LIBOSP_APPFW] == NULL) {
+ lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
+ if (lib_handle[LIBOSP_APPFW] == NULL) {
+ perror("dlopen failed : libosp-appfw.so");
+ exit(0);
+ }
}
tmpPtr =
dlsym(
- lib_handle,
+ lib_handle[LIBOSP_APPFW],
"_ZN5Tizen4Base7Runtime6Thread9ConstructENS1_10ThreadTypeElNS1_14ThreadPriorityE");
if (tmpPtr == NULL || dlerror() != NULL) {
exit(0);
}
- memcpy(&Constructp, &tmpPtr, sizeof(&tmpPtr));
+ memcpy(&Constructp, &tmpPtr, sizeof(tmpPtr));
probeBlockEnd();
}
if (!Constructp) {
probeBlockStart();
- void* lib_handle = dlopen("libosp-appfw.so", RTLD_LAZY);
- if (lib_handle == NULL) {
- perror("dlopen failed : libosp-appfw.so");
- exit(0);
+ if(lib_handle[LIBOSP_APPFW] == NULL) {
+ lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
+ if (lib_handle[LIBOSP_APPFW] == NULL) {
+ perror("dlopen failed : libosp-appfw.so");
+ exit(0);
+ }
}
- tmpPtr = dlsym(lib_handle,
+ tmpPtr = dlsym(lib_handle[LIBOSP_APPFW],
"_ZN5Tizen4Base7Runtime6Thread9ConstructElNS1_14ThreadPriorityE");
if (tmpPtr == NULL || dlerror() != NULL) {
perror("dlsym failed : Tizen::Base::Runtime::Thread::Construct");
exit(0);
}
- memcpy(&Constructp, &tmpPtr, sizeof(&tmpPtr));
+ memcpy(&Constructp, &tmpPtr, sizeof(tmpPtr));
probeBlockEnd();
}
if (!Constructp) {
probeBlockStart();
- void* lib_handle = dlopen("libosp-appfw.so", RTLD_LAZY);
- if (lib_handle == NULL) {
- perror("dlopen failed : libosp-appfw.so");
- exit(0);
+ if(lib_handle[LIBOSP_APPFW] == NULL) {
+ lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
+ if (lib_handle[LIBOSP_APPFW] == NULL) {
+ perror("dlopen failed : libosp-appfw.so");
+ exit(0);
+ }
}
tmpPtr =
dlsym(
- lib_handle,
+ lib_handle[LIBOSP_APPFW],
"_ZN5Tizen4Base7Runtime6Thread9ConstructERKNS0_6StringElNS1_14ThreadPriorityE");
if (tmpPtr == NULL || dlerror() != NULL) {
exit(0);
}
- memcpy(&Constructp, &tmpPtr, sizeof(&tmpPtr));
+ memcpy(&Constructp, &tmpPtr, sizeof(tmpPtr));
probeBlockEnd();
}
if (!Constructp) {
probeBlockStart();
- void* lib_handle = dlopen("libosp-appfw.so", RTLD_LAZY);
- if (lib_handle == NULL) {
- perror("dlopen failed : libosp-appfw.so");
- exit(0);
+ if(lib_handle[LIBOSP_APPFW] == NULL) {
+ lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
+ if (lib_handle[LIBOSP_APPFW] == NULL) {
+ perror("dlopen failed : libosp-appfw.so");
+ exit(0);
+ }
}
tmpPtr =
dlsym(
- lib_handle,
+ lib_handle[LIBOSP_APPFW],
"_ZN5Tizen4Base7Runtime6Thread9ConstructERKNS0_6StringENS1_10ThreadTypeElNS1_14ThreadPriorityE");
if (tmpPtr == NULL || dlerror() != NULL) {
perror("dlsym failed : Tizen::Base::Runtime::Thread::Construct");
exit(0);
}
- memcpy(&Constructp, &tmpPtr, sizeof(&tmpPtr));
+ memcpy(&Constructp, &tmpPtr, sizeof(tmpPtr));
probeBlockEnd();
}
if (!Constructp) {
probeBlockStart();
- void* lib_handle = dlopen("libosp-appfw.so", RTLD_LAZY);
- if (lib_handle == NULL) {
- perror("dlopen failed : libosp-appfw.so");
- exit(0);
+ if(lib_handle[LIBOSP_APPFW] == NULL) {
+ lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
+ if (lib_handle[LIBOSP_APPFW] == NULL) {
+ perror("dlopen failed : libosp-appfw.so");
+ exit(0);
+ }
}
tmpPtr =
dlsym(
- lib_handle,
+ lib_handle[LIBOSP_APPFW],
"_ZN5Tizen4Base7Runtime6Thread9ConstructERNS1_9IRunnableElNS1_14ThreadPriorityE");
if (tmpPtr == NULL || dlerror() != NULL) {
exit(0);
}
- memcpy(&Constructp, &tmpPtr, sizeof(&tmpPtr));
+ memcpy(&Constructp, &tmpPtr, sizeof(tmpPtr));
probeBlockEnd();
}
if (!Constructp) {
probeBlockStart();
- void* lib_handle = dlopen("libosp-appfw.so", RTLD_LAZY);
- if (lib_handle == NULL) {
- perror("dlopen failed : libosp-appfw.so");
- exit(0);
+ if(lib_handle[LIBOSP_APPFW] == NULL) {
+ lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
+ if (lib_handle[LIBOSP_APPFW] == NULL) {
+ perror("dlopen failed : libosp-appfw.so");
+ exit(0);
+ }
}
tmpPtr =
dlsym(
- lib_handle,
+ lib_handle[LIBOSP_APPFW],
"_ZN5Tizen4Base7Runtime6Thread9ConstructERKNS0_6StringERNS1_9IRunnableElNS1_14ThreadPriorityE");
if (tmpPtr == NULL || dlerror() != NULL) {
exit(0);
}
- memcpy(&Constructp, &tmpPtr, sizeof(&tmpPtr));
+ memcpy(&Constructp, &tmpPtr, sizeof(tmpPtr));
probeBlockEnd();
}
if (!GetExitCodep) {
probeBlockStart();
- void* lib_handle = dlopen("libosp-appfw.so", RTLD_LAZY);
- if (lib_handle == NULL) {
- perror("dlopen failed : libosp-appfw.so");
- exit(0);
+ if(lib_handle[LIBOSP_APPFW] == NULL) {
+ lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
+ if (lib_handle[LIBOSP_APPFW] == NULL) {
+ perror("dlopen failed : libosp-appfw.so");
+ exit(0);
+ }
}
- tmpPtr = dlsym(lib_handle,
+ tmpPtr = dlsym(lib_handle[LIBOSP_APPFW],
"_ZNK5Tizen4Base7Runtime6Thread11GetExitCodeERi");
if (tmpPtr == NULL || dlerror() != NULL) {
exit(0);
}
- memcpy(&GetExitCodep, &tmpPtr, sizeof(&tmpPtr));
+ memcpy(&GetExitCodep, &tmpPtr, sizeof(tmpPtr));
probeBlockEnd();
}
if (!GetNamep) {
probeBlockStart();
- void* lib_handle = dlopen("libosp-appfw.so", RTLD_LAZY);
- if (lib_handle == NULL) {
- perror("dlopen failed : libosp-appfw.so");
- exit(0);
+ if(lib_handle[LIBOSP_APPFW] == NULL) {
+ lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
+ if (lib_handle[LIBOSP_APPFW] == NULL) {
+ perror("dlopen failed : libosp-appfw.so");
+ exit(0);
+ }
}
- tmpPtr = dlsym(lib_handle, "_ZNK5Tizen4Base7Runtime6Thread7GetNameEv");
+ tmpPtr = dlsym(lib_handle[LIBOSP_APPFW], "_ZNK5Tizen4Base7Runtime6Thread7GetNameEv");
if (tmpPtr == NULL || dlerror() != NULL) {
perror("dlsym failed : Tizen::Base::Runtime::Thread::GetName");
exit(0);
}
- memcpy(&GetNamep, &tmpPtr, sizeof(&tmpPtr));
+ memcpy(&GetNamep, &tmpPtr, sizeof(tmpPtr));
probeBlockEnd();
}
if (!Joinp) {
probeBlockStart();
- void* lib_handle = dlopen("libosp-appfw.so", RTLD_LAZY);
- if (lib_handle == NULL) {
- perror("dlopen failed : libosp-appfw.so");
- exit(0);
+ if(lib_handle[LIBOSP_APPFW] == NULL) {
+ lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
+ if (lib_handle[LIBOSP_APPFW] == NULL) {
+ perror("dlopen failed : libosp-appfw.so");
+ exit(0);
+ }
}
- tmpPtr = dlsym(lib_handle, "_ZN5Tizen4Base7Runtime6Thread4JoinEv");
+ tmpPtr = dlsym(lib_handle[LIBOSP_APPFW], "_ZN5Tizen4Base7Runtime6Thread4JoinEv");
if (tmpPtr == NULL || dlerror() != NULL) {
perror("dlsym failed : Tizen::Base::Runtime::Thread::Join");
exit(0);
}
- memcpy(&Joinp, &tmpPtr, sizeof(&tmpPtr));
+ memcpy(&Joinp, &tmpPtr, sizeof(tmpPtr));
probeBlockEnd();
}
// return null;
// }
//
-// memcpy(&Runp, &tmpPtr, sizeof(&tmpPtr));
+// memcpy(&Runp, &tmpPtr, sizeof(tmpPtr));
// probeBlockEnd();
// }
//
if (!Startp) {
probeBlockStart();
- void* lib_handle = dlopen("libosp-appfw.so", RTLD_LAZY);
- if (lib_handle == NULL) {
- perror("dlopen failed : libosp-appfw.so");
- exit(0);
+ if(lib_handle[LIBOSP_APPFW] == NULL) {
+ lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
+ if (lib_handle[LIBOSP_APPFW] == NULL) {
+ perror("dlopen failed : libosp-appfw.so");
+ exit(0);
+ }
}
- tmpPtr = dlsym(lib_handle, "_ZN5Tizen4Base7Runtime6Thread5StartEv");
+ tmpPtr = dlsym(lib_handle[LIBOSP_APPFW], "_ZN5Tizen4Base7Runtime6Thread5StartEv");
if (tmpPtr == NULL || dlerror() != NULL) {
perror("dlsym failed : Tizen::Base::Runtime::Thread::Start");
exit(0);
}
- memcpy(&Startp, &tmpPtr, sizeof(&tmpPtr));
+ memcpy(&Startp, &tmpPtr, sizeof(tmpPtr));
probeBlockEnd();
}
if (!Stopp) {
probeBlockStart();
- void* lib_handle = dlopen("libosp-appfw.so", RTLD_LAZY);
- if (lib_handle == NULL) {
- perror("dlopen failed : libosp-appfw.so");
- exit(0);
+ if(lib_handle[LIBOSP_APPFW] == NULL) {
+ lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
+ if (lib_handle[LIBOSP_APPFW] == NULL) {
+ perror("dlopen failed : libosp-appfw.so");
+ exit(0);
+ }
}
- tmpPtr = dlsym(lib_handle, "_ZN5Tizen4Base7Runtime6Thread4StopEv");
+ tmpPtr = dlsym(lib_handle[LIBOSP_APPFW], "_ZN5Tizen4Base7Runtime6Thread4StopEv");
if (tmpPtr == NULL || dlerror() != NULL) {
perror("dlsym failed : Tizen::Base::Runtime::Thread::Stop");
exit(0);
}
- memcpy(&Stopp, &tmpPtr, sizeof(&tmpPtr));
+ memcpy(&Stopp, &tmpPtr, sizeof(tmpPtr));
probeBlockEnd();
}
if (!Constructp) {
probeBlockStart();
- void* lib_handle = dlopen("libosp-appfw.so", RTLD_LAZY);
- if (lib_handle == NULL) {
- perror("dlopen failed : libosp-appfw.so");
- exit(0);
+ if(lib_handle[LIBOSP_APPFW] == NULL) {
+ lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
+ if (lib_handle[LIBOSP_APPFW] == NULL) {
+ perror("dlopen failed : libosp-appfw.so");
+ exit(0);
+ }
}
- tmpPtr = dlsym(lib_handle,
+ tmpPtr = dlsym(lib_handle[LIBOSP_APPFW],
"_ZN5Tizen4Base7Runtime17EventDrivenThread9ConstructElNS1_14ThreadPriorityE");
if (tmpPtr == NULL || dlerror() != NULL) {
perror("dlsym failed : Tizen::Base::Runtime::EventDrivenThread::Construct");
exit(0);
}
- memcpy(&Constructp, &tmpPtr, sizeof(&tmpPtr));
+ memcpy(&Constructp, &tmpPtr, sizeof(tmpPtr));
probeBlockEnd();
}
if (!Constructp) {
probeBlockStart();
- void* lib_handle = dlopen("libosp-appfw.so", RTLD_LAZY);
- if (lib_handle == NULL) {
- perror("dlopen failed : libosp-appfw.so");
- exit(0);
+ if(lib_handle[LIBOSP_APPFW] == NULL) {
+ lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
+ if (lib_handle[LIBOSP_APPFW] == NULL) {
+ perror("dlopen failed : libosp-appfw.so");
+ exit(0);
+ }
}
tmpPtr =
dlsym(
- lib_handle,
+ lib_handle[LIBOSP_APPFW],
"_ZN5Tizen4Base7Runtime17EventDrivenThread9ConstructERKNS0_6StringElNS1_14ThreadPriorityE");
if (tmpPtr == NULL || dlerror() != NULL) {
exit(0);
}
- memcpy(&Constructp, &tmpPtr, sizeof(&tmpPtr));
+ memcpy(&Constructp, &tmpPtr, sizeof(tmpPtr));
probeBlockEnd();
}
if (!Quitp) {
probeBlockStart();
- void* lib_handle = dlopen("libosp-appfw.so", RTLD_LAZY);
- if (lib_handle == NULL) {
- perror("dlopen failed : libosp-appfw.so");
- exit(0);
+ if(lib_handle[LIBOSP_APPFW] == NULL) {
+ lib_handle[LIBOSP_APPFW] = dlopen(lib_string[LIBOSP_APPFW], RTLD_LAZY);
+ if (lib_handle[LIBOSP_APPFW] == NULL) {
+ perror("dlopen failed : libosp-appfw.so");
+ exit(0);
+ }
}
- tmpPtr = dlsym(lib_handle, "_ZN5Tizen4Base7Runtime17EventDrivenThread4QuitEv");
+ tmpPtr = dlsym(lib_handle[LIBOSP_APPFW], "_ZN5Tizen4Base7Runtime17EventDrivenThread4QuitEv");
if (tmpPtr == NULL || dlerror() != NULL) {
perror("dlsym failed : Tizen::Base::Runtime::EventThread::Quit");
exit(0);
}
- memcpy(&Quitp, &tmpPtr, sizeof(&tmpPtr));
+ memcpy(&Quitp, &tmpPtr, sizeof(tmpPtr));
probeBlockEnd();
}
*/
#include "daprobe.h"
+#include "dahelper.h"
#include "dacollection.h"
#include "osp_probe.h"
typedef void (Control::*methodType)(void);
static methodType control_controlp;
- GET_REAL_FUNC_OSP(_ZN5Tizen2Ui7ControlC2Ev, libosp-uifw.so, control_controlp);
+ GET_REAL_FUNC_OSP(_ZN5Tizen2Ui7ControlC2Ev, LIBOSP_UIFW, control_controlp);
probeBlockStart();
add_object_hash_type((void*)this, "Control");
typedef void (Control::*methodType)(void);
static methodType control__controlvoidp;
- GET_REAL_FUNC_OSP(_ZN5Tizen2Ui7ControlD2Ev, libosp-uifw.so, control__controlvoidp);
+ GET_REAL_FUNC_OSP(_ZN5Tizen2Ui7ControlD2Ev, LIBOSP_UIFW, control__controlvoidp);
probeBlockStart();
del_object_hash(static_cast<void*>(this));
typedef void (CustomControlBase::*methodType)(void);
static methodType customcontrolbase_customcontrolbasep;
- GET_REAL_FUNC_OSP(_ZN5Tizen2Ui17CustomControlBaseC2Ev, libosp-uifw.so, customcontrolbase_customcontrolbasep);
+ GET_REAL_FUNC_OSP(_ZN5Tizen2Ui17CustomControlBaseC2Ev, LIBOSP_UIFW, customcontrolbase_customcontrolbasep);
probeBlockStart();
add_object_hash_type((void*)this, "CustomControlBase");
typedef void (Container::*methodType)(void);
static methodType container_containerp;
- GET_REAL_FUNC_OSP(_ZN5Tizen2Ui9ContainerC2Ev, libosp-uifw.so, container_containerp);
+ GET_REAL_FUNC_OSP(_ZN5Tizen2Ui9ContainerC2Ev, LIBOSP_UIFW, container_containerp);
probeBlockStart();
add_object_hash_type((void*)this, "Container");
typedef void (Window::*methodType)(void);
static methodType window_windowp;
- GET_REAL_FUNC_OSP(_ZN5Tizen2Ui6WindowC2Ev, libosp-uifw.so, window_windowp);
+ GET_REAL_FUNC_OSP(_ZN5Tizen2Ui6WindowC2Ev, LIBOSP_UIFW, window_windowp);
probeBlockStart();
add_object_hash_type((void*)this, "Window");
typedef void (Animation::*methodType)(void);
static methodType animation_animationp;
- GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls9AnimationC2Ev, libosp-uifw.so, animation_animationp);
+ GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls9AnimationC2Ev, LIBOSP_UIFW, animation_animationp);
probeBlockStart();
add_object_hash_type((void*)this, "Animation");
typedef void (Button::*methodType)(void);
static methodType button_buttonp;
- GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls6ButtonC2Ev, libosp-uifw.so, button_buttonp);
+ GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls6ButtonC2Ev, LIBOSP_UIFW, button_buttonp);
probeBlockStart();
add_object_hash_type((void*)this, "Button");
typedef void (CheckButton::*methodType)(void);
static methodType checkbutton_checkbuttonp;
- GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls11CheckButtonC2Ev, libosp-uifw.so, checkbutton_checkbuttonp);
+ GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls11CheckButtonC2Ev, LIBOSP_UIFW, checkbutton_checkbuttonp);
probeBlockStart();
add_object_hash_type((void*)this, "CheckButton");
typedef void (ColorPicker::*methodType)(void);
static methodType colorpicker_colorpickerp;
- GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls11ColorPickerC2Ev, libosp-uifw.so, colorpicker_colorpickerp);
+ GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls11ColorPickerC2Ev, LIBOSP_UIFW, colorpicker_colorpickerp);
probeBlockStart();
add_object_hash_type((void*)this, "ColorPicker");
typedef void (CustomList::*methodType)(void);
static methodType customlist_customlistp;
- GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls10CustomListC2Ev, libosp-uifw.so, customlist_customlistp);
+ GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls10CustomListC2Ev, LIBOSP_UIFW, customlist_customlistp);
probeBlockStart();
add_object_hash_type((void*)this, "CustomList");
typedef void (EditArea::*methodType)(void);
static methodType editarea_editareap;
- GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls8EditAreaC2Ev, libosp-uifw.so, editarea_editareap);
+ GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls8EditAreaC2Ev, LIBOSP_UIFW, editarea_editareap);
probeBlockStart();
add_object_hash_type((void*)this, "EditArea");
typedef void (EditDate::*methodType)(void);
static methodType editdate_editdatep;
- GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls8EditDateC2Ev, libosp-uifw.so, editdate_editdatep);
+ GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls8EditDateC2Ev, LIBOSP_UIFW, editdate_editdatep);
probeBlockStart();
add_object_hash_type((void*)this, "EditDate");
typedef void (EditField::*methodType)(void);
static methodType editfield_editfieldp;
- GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls9EditFieldC2Ev, libosp-uifw.so, editfield_editfieldp);
+ GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls9EditFieldC2Ev, LIBOSP_UIFW, editfield_editfieldp);
probeBlockStart();
add_object_hash_type((void*)this, "EditField");
typedef void (EditTime::*methodType)(void);
static methodType edittime_edittimep;
- GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls8EditTimeC2Ev, libosp-uifw.so, edittime_edittimep);
+ GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls8EditTimeC2Ev, LIBOSP_UIFW, edittime_edittimep);
probeBlockStart();
add_object_hash_type((void*)this, "EditTime");
typedef void (ExpandableEditArea::*methodType)(void);
static methodType expandableeditarea_expandableeditareap;
- GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls18ExpandableEditAreaC2Ev, libosp-uifw.so, expandableeditarea_expandableeditareap);
+ GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls18ExpandableEditAreaC2Ev, LIBOSP_UIFW, expandableeditarea_expandableeditareap);
probeBlockStart();
add_object_hash_type((void*)this, "ExpandableEditArea");
typedef void (ExpandableList::*methodType)(void);
static methodType expandablelist_expandablelistp;
- GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls14ExpandableListC2Ev, libosp-uifw.so, expandablelist_expandablelistp);
+ GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls14ExpandableListC2Ev, LIBOSP_UIFW, expandablelist_expandablelistp);
probeBlockStart();
add_object_hash_type((void*)this, "ExpandableList");
typedef void (Footer::*methodType)(void);
static methodType footer_footerp;
- GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls6FooterC2Ev, libosp-uifw.so, footer_footerp);
+ GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls6FooterC2Ev, LIBOSP_UIFW, footer_footerp);
probeBlockStart();
add_object_hash_type((void*)this, "Footer");
typedef void (Gallery::*methodType)(void);
static methodType gallery_galleryp;
- GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls7GalleryC2Ev, libosp-uifw.so, gallery_galleryp);
+ GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls7GalleryC2Ev, LIBOSP_UIFW, gallery_galleryp);
probeBlockStart();
add_object_hash_type((void*)this, "Gallery");
typedef void (GroupedList::*methodType)(void);
static methodType groupedlist_groupedlistp;
- GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls11GroupedListC2Ev, libosp-uifw.so, groupedlist_groupedlistp);
+ GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls11GroupedListC2Ev, LIBOSP_UIFW, groupedlist_groupedlistp);
probeBlockStart();
add_object_hash_type((void*)this, "GroupedList");
typedef void (GroupedListView::*methodType)(void);
static methodType groupedlistview_groupedlistviewp;
- GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls15GroupedListViewC2Ev, libosp-uifw.so, groupedlistview_groupedlistviewp);
+ GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls15GroupedListViewC2Ev, LIBOSP_UIFW, groupedlistview_groupedlistviewp);
probeBlockStart();
add_object_hash_type((void*)this, "GroupedListView");
typedef void (Header::*methodType)(void);
static methodType header_headerp;
- GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls6HeaderC2Ev, libosp-uifw.so, header_headerp);
+ GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls6HeaderC2Ev, LIBOSP_UIFW, header_headerp);
probeBlockStart();
add_object_hash_type((void*)this, "Header");
typedef void (IconList::*methodType)(void);
static methodType iconlist_iconlistp;
- GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls8IconListC2Ev, libosp-uifw.so, iconlist_iconlistp);
+ GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls8IconListC2Ev, LIBOSP_UIFW, iconlist_iconlistp);
probeBlockStart();
add_object_hash_type((void*)this, "IconList");
typedef void (IconListView::*methodType)(void);
static methodType iconlistview_iconlistviewp;
- GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls12IconListViewC2Ev, libosp-uifw.so, iconlistview_iconlistviewp);
+ GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls12IconListViewC2Ev, LIBOSP_UIFW, iconlistview_iconlistviewp);
probeBlockStart();
add_object_hash_type((void*)this, "IconListView");
typedef void (Label::*methodType)(void);
static methodType label_labelp;
- GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls5LabelC2Ev, libosp-uifw.so, label_labelp);
+ GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls5LabelC2Ev, LIBOSP_UIFW, label_labelp);
probeBlockStart();
add_object_hash_type((void*)this, "Label");
typedef void (List::*methodType)(void);
static methodType list_listp;
- GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls4ListC2Ev, libosp-uifw.so, list_listp);
+ GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls4ListC2Ev, LIBOSP_UIFW, list_listp);
probeBlockStart();
add_object_hash_type((void*)this, "List");
typedef void (ListView::*methodType)(void);
static methodType listview_listviewp;
- GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls8ListViewC2Ev, libosp-uifw.so, listview_listviewp);
+ GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls8ListViewC2Ev, LIBOSP_UIFW, listview_listviewp);
probeBlockStart();
add_object_hash_type((void*)this, "ListView");
typedef void (Progress::*methodType)(void);
static methodType progress_progressp;
- GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls8ProgressC2Ev, libosp-uifw.so, progress_progressp);
+ GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls8ProgressC2Ev, LIBOSP_UIFW, progress_progressp);
probeBlockStart();
add_object_hash_type((void*)this, "Progress");
typedef void (RadioGroup::*methodType)(void);
static methodType radiogroup_radiogroupp;
- GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls10RadioGroupC2Ev, libosp-uifw.so, radiogroup_radiogroupp);
+ GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls10RadioGroupC2Ev, LIBOSP_UIFW, radiogroup_radiogroupp);
probeBlockStart();
add_object_hash_type((void*)this, "RadioGroup");
typedef void (SearchBar::*methodType)(void);
static methodType searchbar_searchbarp;
- GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls9SearchBarC2Ev, libosp-uifw.so, searchbar_searchbarp);
+ GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls9SearchBarC2Ev, LIBOSP_UIFW, searchbar_searchbarp);
probeBlockStart();
add_object_hash_type((void*)this, "SearchBar");
typedef void (SlidableGroupedList::*methodType)(void);
static methodType slidablegroupedlist_slidablegroupedlistp;
- GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls19SlidableGroupedListC2Ev, libosp-uifw.so, slidablegroupedlist_slidablegroupedlistp);
+ GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls19SlidableGroupedListC2Ev, LIBOSP_UIFW, slidablegroupedlist_slidablegroupedlistp);
probeBlockStart();
add_object_hash_type((void*)this, "SlidableGroupedList");
typedef void (SlidableList::*methodType)(void);
static methodType slidablelist_slidablelistp;
- GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls12SlidableListC2Ev, libosp-uifw.so, slidablelist_slidablelistp);
+ GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls12SlidableListC2Ev, LIBOSP_UIFW, slidablelist_slidablelistp);
probeBlockStart();
add_object_hash_type((void*)this, "SlidableList");
typedef void (Slider::*methodType)(void);
static methodType slider_sliderp;
- GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls6SliderC2Ev, libosp-uifw.so, slider_sliderp);
+ GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls6SliderC2Ev, LIBOSP_UIFW, slider_sliderp);
probeBlockStart();
add_object_hash_type((void*)this, "Slider");
typedef void (SplitPanel::*methodType)(void);
static methodType splitpanel_splitpanelp;
- GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls10SplitPanelC2Ev, libosp-uifw.so, splitpanel_splitpanelp);
+ GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls10SplitPanelC2Ev, LIBOSP_UIFW, splitpanel_splitpanelp);
probeBlockStart();
add_object_hash_type((void*)this, "SplitPanel");
typedef void (Tab::*methodType)(void);
static methodType tab_tabp;
- GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls3TabC2Ev, libosp-uifw.so, tab_tabp);
+ GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls3TabC2Ev, LIBOSP_UIFW, tab_tabp);
probeBlockStart();
add_object_hash_type((void*)this, "Tab");
typedef void (TabBar::*methodType)(void);
static methodType tabbar_tabbarp;
- GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls6TabBarC2Ev, libosp-uifw.so, tabbar_tabbarp);
+ GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls6TabBarC2Ev, LIBOSP_UIFW, tabbar_tabbarp);
probeBlockStart();
add_object_hash_type((void*)this, "TabBar");
typedef void (TextBox::*methodType)(void);
static methodType textbox_textboxp;
- GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls7TextBoxC2Ev, libosp-uifw.so, textbox_textboxp);
+ GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls7TextBoxC2Ev, LIBOSP_UIFW, textbox_textboxp);
probeBlockStart();
add_object_hash_type((void*)this, "TextBox");
typedef void (Form::*methodType)(void);
static methodType form_formp;
- GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls4FormC2Ev, libosp-uifw.so, form_formp);
+ GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls4FormC2Ev, LIBOSP_UIFW, form_formp);
probeBlockStart();
add_object_hash_type((void*)this, "Form");
typedef void (GroupedTableView::*methodType)(void);
static methodType groupedtableview_groupedtableviewp;
- GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls16GroupedTableViewC2Ev, libosp-uifw.so, groupedtableview_groupedtableviewp);
+ GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls16GroupedTableViewC2Ev, LIBOSP_UIFW, groupedtableview_groupedtableviewp);
probeBlockStart();
add_object_hash_type((void*)this, "GroupedTableView");
typedef void (Panel::*methodType)(void);
static methodType panel_panelp;
- GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls5PanelC2Ev, libosp-uifw.so, panel_panelp);
+ GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls5PanelC2Ev, LIBOSP_UIFW, panel_panelp);
probeBlockStart();
add_object_hash_type((void*)this, "Panel");
typedef void (OverlayPanel::*methodType)(void);
static methodType overlaypanel_overlaypanelp;
- GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls12OverlayPanelC2Ev, libosp-uifw.so, overlaypanel_overlaypanelp);
+ GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls12OverlayPanelC2Ev, LIBOSP_UIFW, overlaypanel_overlaypanelp);
probeBlockStart();
add_object_hash_type((void*)this, "OverlayPanel");
typedef void (ScrollPanel::*methodType)(void);
static methodType scrollpanel_scrollpanelp;
- GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls11ScrollPanelC2Ev, libosp-uifw.so, scrollpanel_scrollpanelp);
+ GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls11ScrollPanelC2Ev, LIBOSP_UIFW, scrollpanel_scrollpanelp);
probeBlockStart();
add_object_hash_type((void*)this, "ScrollPanel");
typedef void (SectionTableView::*methodType)(void);
static methodType sectiontableview_sectiontableviewp;
- GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls16SectionTableViewC2Ev, libosp-uifw.so, sectiontableview_sectiontableviewp);
+ GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls16SectionTableViewC2Ev, LIBOSP_UIFW, sectiontableview_sectiontableviewp);
probeBlockStart();
add_object_hash_type((void*)this, "SectionTableView");
typedef void (TableView::*methodType)(void);
static methodType tableview_tableviewp;
- GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls9TableViewC2Ev, libosp-uifw.so, tableview_tableviewp);
+ GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls9TableViewC2Ev, LIBOSP_UIFW, tableview_tableviewp);
probeBlockStart();
add_object_hash_type((void*)this, "TableView");
typedef void (TableViewItemBase::*methodType)(void);
static methodType tableviewitembase_tableviewitembasep;
- GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls17TableViewItemBaseC2Ev, libosp-uifw.so, tableviewitembase_tableviewitembasep);
+ GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls17TableViewItemBaseC2Ev, LIBOSP_UIFW, tableviewitembase_tableviewitembasep);
probeBlockStart();
add_object_hash_type((void*)this, "TableViewItemBase");
typedef void (TableViewContextItem::*methodType)(void);
static methodType tableviewcontextitem_tableviewcontextitemp;
- GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls20TableViewContextItemC2Ev, libosp-uifw.so, tableviewcontextitem_tableviewcontextitemp);
+ GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls20TableViewContextItemC2Ev, LIBOSP_UIFW, tableviewcontextitem_tableviewcontextitemp);
probeBlockStart();
add_object_hash_type((void*)this, "TableViewContextItem");
typedef void (TableViewGroupItem::*methodType)(void);
static methodType tableviewgroupitem_tableviewgroupitemp;
- GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls18TableViewGroupItemC2Ev, libosp-uifw.so, tableviewgroupitem_tableviewgroupitemp);
+ GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls18TableViewGroupItemC2Ev, LIBOSP_UIFW, tableviewgroupitem_tableviewgroupitemp);
probeBlockStart();
add_object_hash_type((void*)this, "TableViewGroupItem");
typedef void (TableViewItem::*methodType)(void);
static methodType tableviewitem_tableviewitemp;
- GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls13TableViewItemC2Ev, libosp-uifw.so, tableviewitem_tableviewitemp);
+ GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls13TableViewItemC2Ev, LIBOSP_UIFW, tableviewitem_tableviewitemp);
probeBlockStart();
add_object_hash_type((void*)this, "TableViewItem");
typedef void (TableViewSimpleGroupItem::*methodType)(void);
static methodType tableviewsimplegroupitem_tableviewsimplegroupitemp;
- GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls24TableViewSimpleGroupItemC2Ev, libosp-uifw.so, tableviewsimplegroupitem_tableviewsimplegroupitemp);
+ GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls24TableViewSimpleGroupItemC2Ev, LIBOSP_UIFW, tableviewsimplegroupitem_tableviewsimplegroupitemp);
probeBlockStart();
add_object_hash_type((void*)this, "TableViewSimpleGroupItem");
typedef void (TableViewSimpleItem::*methodType)(void);
static methodType tableviewsimpleitem_tableviewsimpleitemp;
- GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls19TableViewSimpleItemC2Ev, libosp-uifw.so, tableviewsimpleitem_tableviewsimpleitemp);
+ GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls19TableViewSimpleItemC2Ev, LIBOSP_UIFW, tableviewsimpleitem_tableviewsimpleitemp);
probeBlockStart();
add_object_hash_type((void*)this, "TableViewSimpleItem");
typedef void (ContextMenu::*methodType)(void);
static methodType contextmenu_contextmenup;
- GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls11ContextMenuC2Ev, libosp-uifw.so, contextmenu_contextmenup);
+ GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls11ContextMenuC2Ev, LIBOSP_UIFW, contextmenu_contextmenup);
probeBlockStart();
add_object_hash_type((void*)this, "ContextMenu");
typedef void (DatePicker::*methodType)(void);
static methodType datepicker_datepickerp;
- GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls10DatePickerC2Ev, libosp-uifw.so, datepicker_datepickerp);
+ GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls10DatePickerC2Ev, LIBOSP_UIFW, datepicker_datepickerp);
probeBlockStart();
add_object_hash_type((void*)this, "DatePicker");
typedef void (DateTimePicker::*methodType)(void);
static methodType datetimepicker_datetimepickerp;
- GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls14DateTimePickerC2Ev, libosp-uifw.so, datetimepicker_datetimepickerp);
+ GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls14DateTimePickerC2Ev, LIBOSP_UIFW, datetimepicker_datetimepickerp);
probeBlockStart();
add_object_hash_type((void*)this, "DateTimePicker");
typedef void (Frame::*methodType)(void);
static methodType frame_framep;
- GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls5FrameC2Ev, libosp-uifw.so, frame_framep);
+ GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls5FrameC2Ev, LIBOSP_UIFW, frame_framep);
probeBlockStart();
add_object_hash_type((void*)this, "Frame");
typedef void (Keypad::*methodType)(void);
static methodType keypad_keypadp;
- GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls6KeypadC2Ev, libosp-uifw.so, keypad_keypadp);
+ GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls6KeypadC2Ev, LIBOSP_UIFW, keypad_keypadp);
probeBlockStart();
add_object_hash_type((void*)this, "Keypad");
typedef void (MessageBox::*methodType)(void);
static methodType messagebox_messageboxp;
- GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls10MessageBoxC2Ev, libosp-uifw.so, messagebox_messageboxp);
+ GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls10MessageBoxC2Ev, LIBOSP_UIFW, messagebox_messageboxp);
probeBlockStart();
add_object_hash_type((void*)this, "MessageBox");
typedef void (NotificationFrame::*methodType)(void);
static methodType notificationframe_notificationframep;
- GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls17NotificationFrameC2Ev, libosp-uifw.so, notificationframe_notificationframep);
+ GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls17NotificationFrameC2Ev, LIBOSP_UIFW, notificationframe_notificationframep);
probeBlockStart();
add_object_hash_type((void*)this, "NotificationFrame");
typedef void (OptionMenu::*methodType)(void);
static methodType optionmenu_optionmenup;
- GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls10OptionMenuC2Ev, libosp-uifw.so, optionmenu_optionmenup);
+ GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls10OptionMenuC2Ev, LIBOSP_UIFW, optionmenu_optionmenup);
probeBlockStart();
add_object_hash_type((void*)this, "OptionMenu");
typedef void (Popup::*methodType)(void);
static methodType popup_popupp;
- GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls5PopupC2Ev, libosp-uifw.so, popup_popupp);
+ GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls5PopupC2Ev, LIBOSP_UIFW, popup_popupp);
probeBlockStart();
add_object_hash_type((void*)this, "Popup");
typedef void (TimePicker::*methodType)(void);
static methodType timepicker_timepickerp;
- GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls10TimePickerC2Ev, libosp-uifw.so, timepicker_timepickerp);
+ GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls10TimePickerC2Ev, LIBOSP_UIFW, timepicker_timepickerp);
probeBlockStart();
add_object_hash_type((void*)this, "TimePicker");
typedef void (Web::*methodType)(void);
static methodType web_webp;
- GET_REAL_FUNC_OSP(_ZN5Tizen3Web8Controls3WebC2Ev, libosp-web.so, web_webp);
+ GET_REAL_FUNC_OSP(_ZN5Tizen3Web8Controls3WebC2Ev, LIBOSP_WEB, web_webp);
probeBlockStart();
add_object_hash_type((void*)this, "Web");
DECLARE_COMMON_VARIABLE;
result ret;
- GET_REAL_FUNC_OSP(_ZN5Tizen3App5UiApp8AddFrameERKNS_2Ui8Controls5FrameE, libosp-uifw.so, uiapp_addframep);
+ GET_REAL_FUNC_OSP(_ZN5Tizen3App5UiApp8AddFrameERKNS_2Ui8Controls5FrameE, LIBOSP_UIFW, uiapp_addframep);
ret = (this->*uiapp_addframep)(frame);
result ret;
bool bOption;
- GET_REAL_FUNC_OSP(_ZN5Tizen3App5UiApp11RemoveFrameERKNS_2Ui8Controls5FrameE, libosp-uifw.so, uiapp_removeframep);
+ GET_REAL_FUNC_OSP(_ZN5Tizen3App5UiApp11RemoveFrameERKNS_2Ui8Controls5FrameE, LIBOSP_UIFW, uiapp_removeframep);
probeBlockStart();
frame.IsInTouchMode();
typedef bool (Control::*methodType)(void) const;
static methodType control_isintouchmodep;
- GET_REAL_FUNC_OSP(_ZNK5Tizen2Ui7Control13IsInTouchModeEv, libosp-uifw.so, control_isintouchmodep);
+ GET_REAL_FUNC_OSP(_ZNK5Tizen2Ui7Control13IsInTouchModeEv, LIBOSP_UIFW, control_isintouchmodep);
probeBlockStart();
add_object_hash_class((void*)(this), typeid(*this).name());
static methodType control_setnamep;
DECLARE_COMMON_VARIABLE;
- GET_REAL_FUNC_OSP(_ZN5Tizen2Ui7Control7SetNameERKNS_4Base6StringE, libosp-uifw.so, control_setnamep);
+ GET_REAL_FUNC_OSP(_ZN5Tizen2Ui7Control7SetNameERKNS_4Base6StringE, LIBOSP_UIFW, control_setnamep);
(this->*control_setnamep)(name);
DECLARE_COMMON_VARIABLE;
result ret;
- GET_REAL_FUNC_OSP(_ZN5Tizen2Ui9Container10AddControlERKNS0_7ControlE, libosp-uifw.so, container_addcontrolp);
+ GET_REAL_FUNC_OSP(_ZN5Tizen2Ui9Container10AddControlERKNS0_7ControlE, LIBOSP_UIFW, container_addcontrolp);
probeBlockStart();
if(unlikely(IsRegisteredFrameAnimatorEventListener == false))
result ret;
bool bOption;
- GET_REAL_FUNC_OSP(_ZN5Tizen2Ui9Container13RemoveControlERKNS0_7ControlE, libosp-uifw.so, container_removecontrolp);
+ GET_REAL_FUNC_OSP(_ZN5Tizen2Ui9Container13RemoveControlERKNS0_7ControlE, LIBOSP_UIFW, container_removecontrolp);
probeBlockStart();
control.IsInTouchMode();
result ret;
bool bOption;
- GET_REAL_FUNC_OSP(_ZN5Tizen2Ui9Container13RemoveControlEi, libosp-uifw.so, container_removecontrolip);
+ GET_REAL_FUNC_OSP(_ZN5Tizen2Ui9Container13RemoveControlEi, LIBOSP_UIFW, container_removecontrolip);
probeBlockStart();
Control* pcontrol = GetControl(index);
static methodType container_removeallcontrolp;
DECLARE_COMMON_VARIABLE;
- GET_REAL_FUNC_OSP(_ZN5Tizen2Ui9Container17RemoveAllControlsEv, libosp-uifw.so, container_removeallcontrolp);
+ GET_REAL_FUNC_OSP(_ZN5Tizen2Ui9Container17RemoveAllControlsEv, LIBOSP_UIFW, container_removeallcontrolp);
probeBlockStart();
if(isOptionEnabled(OPT_UI))
result iret;
GET_REAL_FUNC_OSP(_ZN5Tizen2Ui25TouchFlickGestureDetector28AddFlickGestureEventListenerERNS0_31ITouchFlickGestureEventListenerE,
- libosp-uifw.so, addflickgestureeventlistenerp);
+ LIBOSP_UIFW, addflickgestureeventlistenerp);
probeBlockStart();
GestureEventListener& mylistener = GestureEventListener::GetInstance();
result iret;
GET_REAL_FUNC_OSP(_ZN5Tizen2Ui29TouchLongPressGestureDetector32AddLongPressGestureEventListenerERNS0_35ITouchLongPressGestureEventListenerE,
- libosp-uifw.so, addlongpressgestureeventlistenerp);
+ LIBOSP_UIFW, addlongpressgestureeventlistenerp);
probeBlockStart();
GestureEventListener& mylistener = GestureEventListener::GetInstance();
result iret;
GET_REAL_FUNC_OSP(_ZN5Tizen2Ui27TouchPanningGestureDetector30AddPanningGestureEventListenerERNS0_33ITouchPanningGestureEventListenerE,
- libosp-uifw.so, addpanninggestureeventlistenerp);
+ LIBOSP_UIFW, addpanninggestureeventlistenerp);
probeBlockStart();
GestureEventListener& mylistener = GestureEventListener::GetInstance();
result iret;
GET_REAL_FUNC_OSP(_ZN5Tizen2Ui25TouchPinchGestureDetector28AddPinchGestureEventListenerERNS0_31ITouchPinchGestureEventListenerE,
- libosp-uifw.so, addpinchgestureeventlistenerp);
+ LIBOSP_UIFW, addpinchgestureeventlistenerp);
probeBlockStart();
GestureEventListener& mylistener = GestureEventListener::GetInstance();
result iret;
GET_REAL_FUNC_OSP(_ZN5Tizen2Ui28TouchRotationGestureDetector31AddRotationGestureEventListenerERNS0_34ITouchRotationGestureEventListenerE,
- libosp-uifw.so, addrotationgestureeventlistenerp);
+ LIBOSP_UIFW, addrotationgestureeventlistenerp);
probeBlockStart();
GestureEventListener& mylistener = GestureEventListener::GetInstance();
result iret;
GET_REAL_FUNC_OSP(_ZN5Tizen2Ui23TouchTapGestureDetector26AddTapGestureEventListenerERNS0_29ITouchTapGestureEventListenerE,
- libosp-uifw.so, addtapgestureeventlistenerp);
+ LIBOSP_UIFW, addtapgestureeventlistenerp);
probeBlockStart();
GestureEventListener& mylistener = GestureEventListener::GetInstance();
result iret;
GET_REAL_FUNC_OSP(_ZN5Tizen2Ui20TouchGestureDetector23AddGestureEventListenerERNS0_26ITouchGestureEventListenerE,
- libosp-uifw.so, addgestureeventlistenerp);
+ LIBOSP_UIFW, addgestureeventlistenerp);
probeBlockStart();
GestureEventListener& mylistener = GestureEventListener::GetInstance();
bool touch_pressed = false;
-#define LIBECOREINPUT libecore_input_evas.so.1
-
#define HW_EVENT_LOG(_EVENTTYPE, _DETAILTYPE, _X, _Y, _KEYCODE, _EXTRA) \
setProbePoint(&probeInfo); \
INIT_LOG; \
static Eina_Bool (*ecore_event_evas_key_downp)(void *data, int type, void *event);
DECLARE_COMMON_VARIABLE;
- GET_REAL_FUNC(ecore_event_evas_key_down, LIBECOREINPUT);
+ GET_REAL_FUNC(ecore_event_evas_key_down, LIBECORE_INPUT_EVAS);
if(isOptionEnabled(OPT_EVENT))
{
static Eina_Bool (*ecore_event_evas_key_upp)(void *data, int type, void *event);
DECLARE_COMMON_VARIABLE;
- GET_REAL_FUNC(ecore_event_evas_key_up, LIBECOREINPUT);
+ GET_REAL_FUNC(ecore_event_evas_key_up, LIBECORE_INPUT_EVAS);
if(isOptionEnabled(OPT_EVENT))
{
static Eina_Bool (*ecore_event_evas_mouse_button_downp)(void *data, int type, void *event);
DECLARE_COMMON_VARIABLE;
- GET_REAL_FUNC(ecore_event_evas_mouse_button_down, LIBECOREINPUT);
+ GET_REAL_FUNC(ecore_event_evas_mouse_button_down, LIBECORE_INPUT_EVAS);
if(isOptionEnabled(OPT_EVENT))
{
static Eina_Bool (*ecore_event_evas_mouse_button_upp)(void *data, int type, void *event);
DECLARE_COMMON_VARIABLE;
- GET_REAL_FUNC(ecore_event_evas_mouse_button_up, LIBECOREINPUT);
+ GET_REAL_FUNC(ecore_event_evas_mouse_button_up, LIBECORE_INPUT_EVAS);
if(isOptionEnabled(OPT_EVENT))
{
static Eina_Bool (*ecore_event_evas_mouse_movep)(void *data, int type, void *event);
DECLARE_COMMON_VARIABLE;
- GET_REAL_FUNC(ecore_event_evas_mouse_move, LIBECOREINPUT);
+ GET_REAL_FUNC(ecore_event_evas_mouse_move, LIBECORE_INPUT_EVAS);
if(isOptionEnabled(OPT_EVENT))
{
#define AFTER_ORIGINAL_FILEP_RET(RTYPE, RVAL, SIZE, FILEP, APITYPE, INPUTFORMAT, ...) \\r
POST_PROBEBLOCK_BEGIN(LC_RESOURCE, RTYPE, RVAL, INPUTFORMAT, __VA_ARGS__); \\r
GET_FD_FROM_FILEP(FILEP); \\r
- _fstatret = fstat(_fd, &_statbuf); \\r
+ if(_fd != -1) { \\r
+ _fstatret = fstat(_fd, &_statbuf); \\r
+ } \\r
if(_fstatret != 0) PRINTMSG("ERROR : fstat error\n"); \\r
POST_PROBEBLOCK_MIDDLE_FD(SIZE, _fd, APITYPE); \\r
POST_PROBEBLOCK_CALLSTACK_RESOURCE(APITYPE); \\r
#include "daprobe.h"
#include "probeinfo.h"
#include "dautil.h"
+#include "dahelper.h"
#include "da_io.h"
#include <fcntl.h>
static int (*openp)(const char* path, int oflag, ...);
int mode = 0;
- BEFORE_ORIGINAL_FILE_NOFILTER(open, libc.so.6);
+ BEFORE_ORIGINAL_FILE_NOFILTER(open, LIBC);
_filepath = (char*)path;
if(oflag & O_CREAT)
static int (*openatp)(int fd, const char* path, int oflag, ...);
int mode = 0;
- BEFORE_ORIGINAL_FILE_NOFILTER(openat, libc.so.6);
+ BEFORE_ORIGINAL_FILE_NOFILTER(openat, LIBC);
_filepath = (char*)path;
if(oflag & O_CREAT)
{
static int (*creatp)(const char* path, mode_t mode);
- BEFORE_ORIGINAL_FILE_NOFILTER(creat, libc.so.6);
+ BEFORE_ORIGINAL_FILE_NOFILTER(creat, LIBC);
_filepath = (char*)path;
ret = creatp(path, mode);
static int (*closep)(int fd);
DECLARE_VARIABLE_FD;
- GET_REAL_FUNC(close, libc.so.6);
+ GET_REAL_FUNC(close, LIBC);
bfiltering = false;
PRE_PROBEBLOCK_BEGIN();
{
static int (*accessp)(const char *path, int amode);
- BEFORE_ORIGINAL_FILE(access, libc.so.6);
+ BEFORE_ORIGINAL_FILE(access, LIBC);
_filepath = (char*)path;
ret = accessp(path, amode);
{
static int (*faccessatp)(int fd, const char *path, int amode, int flag);
- BEFORE_ORIGINAL_FILE(faccessat, libc.so.6);
+ BEFORE_ORIGINAL_FILE(faccessat, LIBC);
_filepath = (char*)path;
ret = faccessatp(fd, path, amode, flag);
static int (*lseekp)(int fd, off_t offset, int whence);
off_t offret;
- BEFORE_ORIGINAL_FILE(lseek, libc.so.6);
+ BEFORE_ORIGINAL_FILE(lseek, LIBC);
offret = lseekp(fd, offset, whence);
{
static int (*fsyncp)(int fd);
- BEFORE_ORIGINAL_FILE(fsync, libc.so.6);
+ BEFORE_ORIGINAL_FILE(fsync, LIBC);
ret = fsyncp(fd);
{
static int (*fdatasyncp)(int fd);
- BEFORE_ORIGINAL_FILE(fdatasync, libc.so.6);
+ BEFORE_ORIGINAL_FILE(fdatasync, LIBC);
ret = fdatasyncp(fd);
{
static int (*truncatep)(const char *path, off_t length);
- BEFORE_ORIGINAL_FILE(truncate, libc.so.6);
+ BEFORE_ORIGINAL_FILE(truncate, LIBC);
_filepath = (char*)path;
ret = truncatep(path, length);
{
static int (*ftruncatep)(int fd, off_t length);
- BEFORE_ORIGINAL_FILE(ftruncate, libc.so.6);
+ BEFORE_ORIGINAL_FILE(ftruncate, LIBC);
ret = ftruncatep(fd, length);
{
static int (*mkfifop)(const char *path, mode_t mode);
- BEFORE_ORIGINAL_FILE(mkfifo, libc.so.6);
+ BEFORE_ORIGINAL_FILE(mkfifo, LIBC);
_filepath = (char*)path;
ret = mkfifop(path, mode);
{
static int (*mkfifoatp)(int fd, const char *path, mode_t mode);
- BEFORE_ORIGINAL_FILE(mkfifoat, libc.so.6);
+ BEFORE_ORIGINAL_FILE(mkfifoat, LIBC);
_filepath = (char*)path;
ret = mkfifoatp(fd, path, mode);
{
static int (*mknodp)(const char *path, mode_t mode, dev_t dev);
- BEFORE_ORIGINAL_FILE(mknod, libc.so.6);
+ BEFORE_ORIGINAL_FILE(mknod, LIBC);
_filepath = (char*)path;
ret = mknodp(path, mode, dev);
{
static int (*mknodatp)(int fd, const char *path, mode_t mode, dev_t dev);
- BEFORE_ORIGINAL_FILE(mknodat, libc.so.6);
+ BEFORE_ORIGINAL_FILE(mknodat, LIBC);
_filepath = (char*)path;
ret = mknodatp(fd,path, mode,dev);
{
static int (*chownp)(const char *path, uid_t owner, gid_t group);
- BEFORE_ORIGINAL_FILE(chown, libc.so.6);
+ BEFORE_ORIGINAL_FILE(chown, LIBC);
_filepath = (char*)path;
ret = chownp(path, owner, group);
AFTER_ORIGINAL_NOFD(0, FD_API_PERMISSION, "%s, %u, %u", path, owner, group);
{
static int (*fchownatp)(int fd, const char *path, uid_t owner, gid_t group, int flag);
- BEFORE_ORIGINAL_FILE(fchownat, libc.so.6);
+ BEFORE_ORIGINAL_FILE(fchownat, LIBC);
_filepath = (char*)path;
ret = fchownatp(fd, path, owner, group, flag);
AFTER_ORIGINAL_FD(0, fd, FD_API_PERMISSION,
{
static int (*fchownp)(int fd, uid_t owner, gid_t group);
- BEFORE_ORIGINAL_FILE(fchown, libc.so.6);
+ BEFORE_ORIGINAL_FILE(fchown, LIBC);
ret = fchownp(fd, owner, group);
AFTER_ORIGINAL_FD(0, fd, FD_API_PERMISSION, "%d, %u, %u", fd, owner, group);
return ret;
{
static int (*lchownp)(const char *path, uid_t owner, gid_t group);
- BEFORE_ORIGINAL_FILE(lchown, libc.so.6);
+ BEFORE_ORIGINAL_FILE(lchown, LIBC);
_filepath = (char*)path;
ret = lchownp(path, owner, group);
AFTER_ORIGINAL_NOFD(0, FD_API_PERMISSION, "%s, %u, %u", path, owner, group);
{
static int (*lockfp)(int fd, int function, off_t size);
- BEFORE_ORIGINAL_FILE(lockf, libc.so.6);
+ BEFORE_ORIGINAL_FILE(lockf, LIBC);
ret = lockfp(fd, function, size);
AFTER_ORIGINAL_FD((unsigned int)size, fd, FD_API_PERMISSION,
"%d, %d, %ld", fd, function, size);
{
static int (*chmodp)(const char *path, mode_t mode);
- BEFORE_ORIGINAL_FILE(chmod, libc.so.6);
+ BEFORE_ORIGINAL_FILE(chmod, LIBC);
_filepath = (char*)path;
ret = chmodp(path, mode);
AFTER_ORIGINAL_NOFD(0, FD_API_PERMISSION, "%s, %u", path, mode);
{
static int (*fchmodatp)(int fd, const char *path, mode_t mode, int flag);
- BEFORE_ORIGINAL_FILE(fchmodat, libc.so.6);
+ BEFORE_ORIGINAL_FILE(fchmodat, LIBC);
_filepath = (char*)path;
ret = fchmodatp(fd, path, mode, flag);
AFTER_ORIGINAL_FD(0, fd, FD_API_PERMISSION,
{
static int (*fchmodp)(int fd, mode_t mode);
- BEFORE_ORIGINAL_FILE(fchmod, libc.so.6);
+ BEFORE_ORIGINAL_FILE(fchmod, LIBC);
ret = fchmodp(fd, mode);
AFTER_ORIGINAL_FD(0, fd, FD_API_PERMISSION, "%d, %u", fd, mode);
return ret;
static ssize_t (*preadp)(int fd, void *buf, size_t nbyte, off_t offset);
ssize_t sret;
- BEFORE_ORIGINAL_FILE(pread, libc.so.6);
+ BEFORE_ORIGINAL_FILE(pread, LIBC);
sret = preadp(fd, buf, nbyte, offset);
static ssize_t (*readp)(int fildes, void *buf, size_t nbyte);
ssize_t sret;
- BEFORE_ORIGINAL_FILE(read, libc.so.6);
+ BEFORE_ORIGINAL_FILE(read, LIBC);
sret = readp(fd, buf, nbyte);
static ssize_t (*pwritep)(int fd, const void *buf, size_t nbyte, off_t offset);
ssize_t sret;
- BEFORE_ORIGINAL_FILE(pwrite, libc.so.6);
+ BEFORE_ORIGINAL_FILE(pwrite, LIBC);
sret = pwritep(fd, buf, nbyte, offset);
static ssize_t (*writep)(int fildes, const void *buf, size_t nbyte);
ssize_t sret;
- BEFORE_ORIGINAL_FILE(write, libc.so.6);
+ BEFORE_ORIGINAL_FILE(write, LIBC);
sret = writep(fd, buf, nbyte);
static ssize_t (*readvp)(int fd, const struct iovec *iov, int iovcnt);
ssize_t sret;
- BEFORE_ORIGINAL_FILE(readv, libc.so.6);
+ BEFORE_ORIGINAL_FILE(readv, LIBC);
sret = readvp(fd,iov,iovcnt);
AFTER_ORIGINAL_FD_RET(VT_SSIZE_T, sret, (unsigned int)sret, fd, FD_API_READ,
{
static ssize_t (*writevp)(int fd, const struct iovec *iov, int iovcnt);
- MAKE_RESOURCE_PREBLOCK(writev, libc.so.6,3,VT_INT,fd,VT_PTR,iov,VT_INT,iovcnt);
+ MAKE_RESOURCE_PREBLOCK(writev, LIBC,3,VT_INT,fd,VT_PTR,iov,VT_INT,iovcnt);
ssize_t ret;
ret = writevp(fd,iov,iovcnt);
MAKE_RESOURCE_POSTBLOCK(VT_SSIZE_T,ret,VT_SSIZE_T,ret,VT_INT,fd, FD_API_WRITE);
{
static int (*rmdirp)(const char *path);
- BEFORE_ORIGINAL_FILE(rmdir, libc.so.6);
+ BEFORE_ORIGINAL_FILE(rmdir, LIBC);
_filepath = (char*)path;
ret = rmdirp(path);
AFTER_ORIGINAL_NOFD(0, FD_API_DIRECTORY, "%s", path);
{
static int (*fchdirp)(int fd);
- BEFORE_ORIGINAL_FILE(fchdir, libc.so.6);
+ BEFORE_ORIGINAL_FILE(fchdir, LIBC);
ret = fchdirp(fd);
AFTER_ORIGINAL_FD(0, fd, FD_API_DIRECTORY, "%d", fd);
return ret;
{
static int (*chdirp)(const char *path);
- BEFORE_ORIGINAL_FILE(chdir, libc.so.6);
+ BEFORE_ORIGINAL_FILE(chdir, LIBC);
_filepath = (char*)path;
ret = chdirp(path);
AFTER_ORIGINAL_NOFD(0, FD_API_DIRECTORY, "%s", path);
{
static int (*linkp)(const char *path1, const char *path2);
- BEFORE_ORIGINAL_FILE(link, libc.so.6);
+ BEFORE_ORIGINAL_FILE(link, LIBC);
_filepath = (char*)path1;
ret = linkp(path1, path2);
AFTER_ORIGINAL_NOFD(0, FD_API_DIRECTORY, "%s, %s", path1, path2);
{
static int (*linkatp)(int fd1, const char *path1, int fd2, const char *path2, int flag);
- BEFORE_ORIGINAL_FILE(linkat, libc.so.6);
+ BEFORE_ORIGINAL_FILE(linkat, LIBC);
_filepath = (char*)path1;
ret = linkatp(fd1, path1, fd2, path2, flag);
AFTER_ORIGINAL_FD(0, fd2, FD_API_DIRECTORY,
{
static int (*unlinkp)(const char *path);
- BEFORE_ORIGINAL_FILE(unlink, libc.so.6);
+ BEFORE_ORIGINAL_FILE(unlink, LIBC);
_filepath = (char*)path;
ret = unlinkp(path);
AFTER_ORIGINAL_NOFD(0, FD_API_DIRECTORY, "%s", path);
{
static int (*unlinkatp)(int fd, const char *path, int flag);
- BEFORE_ORIGINAL_FILE(unlinkat, libc.so.6);
+ BEFORE_ORIGINAL_FILE(unlinkat, LIBC);
_filepath = (char*)path;
ret = unlinkatp(fd, path, flag);
AFTER_ORIGINAL_FD(0, fd, FD_API_DIRECTORY, "%d, %s, %d", fd, path, flag);
{
static int (*symlinkp)(const char *path1, const char *path2);
- BEFORE_ORIGINAL_FILE(symlink, libc.so.6);
+ BEFORE_ORIGINAL_FILE(symlink, LIBC);
_filepath = (char*)path1;
ret = symlinkp(path1, path2);
AFTER_ORIGINAL_NOFD(0, FD_API_DIRECTORY, "%s, %s", path1, path2);
{
static int (*symlinkatp)(const char *path1, int fd, const char *path2);
- BEFORE_ORIGINAL_FILE(symlinkat, libc.so.6);
+ BEFORE_ORIGINAL_FILE(symlinkat, LIBC);
_filepath = (char*)path1;
ret = symlinkatp(path1, fd, path2);
AFTER_ORIGINAL_FD(0, fd, FD_API_DIRECTORY, "%s, %d, %s", path1, fd, path2);
static int (*readlinkp)(const char* path, char* buf, size_t bufsize);
ssize_t sret;
- BEFORE_ORIGINAL_FILE(readlink, libc.so.6);
+ BEFORE_ORIGINAL_FILE(readlink, LIBC);
_filepath = (char*)path;
sret = readlinkp(path, buf, bufsize);
static int (*readlinkatp)(int fd, const char * path, char * buf, size_t bufsize);
ssize_t sret;
- BEFORE_ORIGINAL_FILE(readlinkat, libc.so.6);
+ BEFORE_ORIGINAL_FILE(readlinkat, LIBC);
_filepath = (char*)path;
sret = readlinkatp(fd, path, buf, bufsize);
{
static int (*mkdirp)(const char *path, mode_t mode);
- BEFORE_ORIGINAL_FILE(mkdir, libc.so.6);
+ BEFORE_ORIGINAL_FILE(mkdir, LIBC);
_filepath = (char*)path;
ret = mkdirp(path, mode);
AFTER_ORIGINAL_NOFD(0, FD_API_DIRECTORY, "%s, %u", path, mode);
{
static int (*mkdiratp)(int fd, const char *path, mode_t mode);
- BEFORE_ORIGINAL_FILE(mkdirat, libc.so.6);
+ BEFORE_ORIGINAL_FILE(mkdirat, LIBC);
_filepath = (char*)path;
ret = mkdiratp(fd, path, mode);
AFTER_ORIGINAL_FD(0, fd, FD_API_DIRECTORY, "%d, %s, %u", fd, path, mode);
{
static int (*closedirp)(DIR *dirp);
- BEFORE_ORIGINAL_FILE(closedir, libc.so.6);
+ BEFORE_ORIGINAL_FILE(closedir, LIBC);
ret = closedirp(dirp);
AFTER_ORIGINAL_NOFD(0, FD_API_DIRECTORY, "%p", dirp);
return ret;
static DIR* (*fdopendirp)(int fd);
DIR* dret;
- BEFORE_ORIGINAL_FILE(fdopendir, libc.so.6);
+ BEFORE_ORIGINAL_FILE(fdopendir, LIBC);
dret = fdopendirp(fd);
static DIR* (*opendirp)(const char *dirname);
DIR* dret;
- BEFORE_ORIGINAL_FILE(opendir, libc.so.6);
+ BEFORE_ORIGINAL_FILE(opendir, LIBC);
_filepath = (char*)dirname;
dret = opendirp(dirname);
static struct dirent* (*readdirp)(DIR *dirp);
struct dirent* dret;
- BEFORE_ORIGINAL_FILE(readdir, libc.so.6);
+ BEFORE_ORIGINAL_FILE(readdir, LIBC);
dret = readdirp(dirp);
{
static int (*readdir_rp)(DIR * dirp, struct dirent * entry, struct dirent ** result);
- BEFORE_ORIGINAL_FILE(readdir_r, libc.so.6);
+ BEFORE_ORIGINAL_FILE(readdir_r, LIBC);
ret = readdir_rp(dirp, entry, result);
AFTER_ORIGINAL_NOFD(0, FD_API_DIRECTORY, "%p, %p, %p", dirp, entry, result);
return ret;
{
static void (*rewinddirp)(DIR *dirp);
- BEFORE_ORIGINAL_FILE(rewinddir, libc.so.6);
+ BEFORE_ORIGINAL_FILE(rewinddir, LIBC);
rewinddirp(dirp);
{
static void (*seekdirp)(DIR *dirp, long loc);
- BEFORE_ORIGINAL_FILE(seekdir, libc.so.6);
+ BEFORE_ORIGINAL_FILE(seekdir, LIBC);
seekdirp(dirp, loc);
static int (*telldirp)(DIR *dirp);
long lret;
- BEFORE_ORIGINAL_FILE(telldir, libc.so.6);
+ BEFORE_ORIGINAL_FILE(telldir, LIBC);
lret = telldirp(dirp);
static int (*fcntlp)(int fd, int cmd, ...);
int arg = 0;
- BEFORE_ORIGINAL_FILE(fcntl, libc.so.6);
+ BEFORE_ORIGINAL_FILE(fcntl, LIBC);
va_list argl;
va_start(argl, cmd);
{
static int (*dupp)(int fd);
- BEFORE_ORIGINAL_FILE_NOFILTER(dup, libc.so.6);
+ BEFORE_ORIGINAL_FILE_NOFILTER(dup, LIBC);
ret = dupp(fd);
{
static int (*dup2p)(int fd, int fd2);
- BEFORE_ORIGINAL_FILE_NOFILTER(dup2, libc.so.6);
+ BEFORE_ORIGINAL_FILE_NOFILTER(dup2, LIBC);
ret = dup2p(fd, fd2);
}
//FIXME dlsym error
-// fstat is not in libc.so.6
+// fstat is not in LIBC
#if 0
int fstat(int fd, struct stat *buf)
{
static int (*fstatp)(int fd, struct stat *buf);
- BEFORE_ORIGINAL_FILE(fstat, libc.so.6);
+ BEFORE_ORIGINAL_FILE(fstat, LIBC);
ret = fstatp(fd, buf);
AFTER_ORIGINAL_FD(0, fd, FD_API_OTHER, "%d, %p", fd, buf);
return ret;
{
static int (*statp)(const char * path, struct stat * buf);
- BEFORE_ORIGINAL_FILE(stat, libc.so.6);
+ BEFORE_ORIGINAL_FILE(stat, LIBC);
_filepath = (char*)path;
ret = statp(path, buf);
AFTER_ORIGINAL_NOFD(0, FD_API_OTHER, "%s, %p", path, buf);
{
static int (*fstatatp)(int fd, const char * path, struct stat * buf, int flag);
- BEFORE_ORIGINAL_FILE(fstatat, libc.so.6);
+ BEFORE_ORIGINAL_FILE(fstatat, LIBC);
_filepath = (char*)path;
ret = fstatatp(fd, path, buf, flag);
AFTER_ORIGINAL_FD(0, fd, FD_API_OTHER, "%d, %s, %p, %d", fd, path, buf, flag);
{
static int (*lstatp)(const char * path, struct stat * buf);
- BEFORE_ORIGINAL_FILE(lstat, libc.so.6);
+ BEFORE_ORIGINAL_FILE(lstat, LIBC);
_filepath = (char*)path;
ret = lstatp(path, buf);
AFTER_ORIGINAL_NOFD(0, FD_API_OTHER, "%s, %p", path, buf);
{
static int (*futimensp)(int fd, const struct timespec times[2]);
- BEFORE_ORIGINAL_FILE(futimens, libc.so.6);
+ BEFORE_ORIGINAL_FILE(futimens, LIBC);
ret = futimensp(fd, times);
AFTER_ORIGINAL_FD(0, fd, FD_API_OTHER, "%d, %p", fd, times);
return ret;
{
static int (*utimensatp)(int fd, const char *path, const struct timespec times[2], int flag);
- BEFORE_ORIGINAL_FILE(utimensat, libc.so.6);
+ BEFORE_ORIGINAL_FILE(utimensat, LIBC);
_filepath = (char*)path;
ret = utimensatp(fd, path, times, flag);
AFTER_ORIGINAL_FD(0, fd, FD_API_OTHER,
{
static int (*utimesp)(const char *path, const struct timeval times[2]);
- BEFORE_ORIGINAL_FILE(utimes, libc.so.6);
+ BEFORE_ORIGINAL_FILE(utimes, LIBC);
_filepath = (char*)path;
ret = utimesp(path, times);
AFTER_ORIGINAL_NOFD(0, FD_API_OTHER, "%s, %p", path, times);
{
static int (*utimep)(const char *path, const struct utimbuf *times);
- BEFORE_ORIGINAL_FILE(utime, libc.so.6);
+ BEFORE_ORIGINAL_FILE(utime, LIBC);
_filepath = (char*)path;
ret = utimep(path, times);
AFTER_ORIGINAL_NOFD(0, FD_API_OTHER, "%s, %p", path, times);
#include "daprobe.h"
#include "probeinfo.h"
#include "dautil.h"
+#include "dahelper.h"
#include "da_io.h"
static enum DaOptions _sopt = OPT_FILE;
static FILE* (*fopenp)(const char* filename, const char* mode);
FILE* fret;
- BEFORE_ORIGINAL_FILE_NOFILTER(fopen, libc.so.6);
+ BEFORE_ORIGINAL_FILE_NOFILTER(fopen, LIBC);
_filepath = (char*)filename;
fret = fopenp(filename, mode);
static FILE* (*freopenp)(const char * filename, const char * mode, FILE * stream);
FILE* fret;
- BEFORE_ORIGINAL_FILE_NOFILTER(freopen, libc.so.6);
+ BEFORE_ORIGINAL_FILE_NOFILTER(freopen, LIBC);
_filepath = (char*)filename;
fret = freopenp(filename, mode, stream);
static FILE* (*fdopenp)(int fildes, const char *mode);
FILE* fret;
- BEFORE_ORIGINAL_FILE_NOFILTER(fdopen, libc.so.6);
+ BEFORE_ORIGINAL_FILE_NOFILTER(fdopen, LIBC);
fret = fdopenp(fildes, mode);
{
static int (*fflushp)(FILE* stream);
- BEFORE_ORIGINAL_FILE(fflush, libc.so.6);
+ BEFORE_ORIGINAL_FILE(fflush, LIBC);
ret = fflushp(stream);
AFTER_ORIGINAL_FILEP(0, stream, FD_API_OTHER, "%p", stream);
return ret;
static int (*fclosep)(FILE* stream);
DECLARE_VARIABLE_FD;
- GET_REAL_FUNC(fclose, libc.so.6);
+ GET_REAL_FUNC(fclose, LIBC);
bfiltering = false;
PRE_PROBEBLOCK_BEGIN();
{
static int (*removep)(const char* filename);
- BEFORE_ORIGINAL_FILE(remove, libc.so.6);
+ BEFORE_ORIGINAL_FILE(remove, LIBC);
_filepath = (char*)filename;
ret = removep(filename);
AFTER_ORIGINAL_NOFD(0, FD_API_DIRECTORY, "%s", filename);
{
static int (*renamep)(const char* oldname, const char* newname);
- BEFORE_ORIGINAL_FILE(rename, libc.so.6);
+ BEFORE_ORIGINAL_FILE(rename, LIBC);
_filepath = (char*)newname;
ret = renamep(oldname, newname);
AFTER_ORIGINAL_NOFD(0, FD_API_DIRECTORY, "%s, %s", oldname, newname);
static FILE* (*tmpfilep) ( void );
FILE* fret;
- BEFORE_ORIGINAL_FILE_NOFILTER(tmpfile, libc.so.6);
+ BEFORE_ORIGINAL_FILE_NOFILTER(tmpfile, LIBC);
_filepath = "<temp file>";
fret = tmpfilep();
{
static int (*fgetposp)(FILE* stream, fpos_t* position);
- BEFORE_ORIGINAL_FILE(fgetpos, libc.so.6);
+ BEFORE_ORIGINAL_FILE(fgetpos, LIBC);
ret = fgetposp(stream, position);
AFTER_ORIGINAL_FILEP(0, stream, FD_API_OTHER, "%p, %p", stream, position);
return ret;
{
static int (*fseekp)(FILE* stream, long int offset, int origin);
- BEFORE_ORIGINAL_FILE(fseek, libc.so.6);
+ BEFORE_ORIGINAL_FILE(fseek, LIBC);
ret = fseekp(stream, offset, origin);
AFTER_ORIGINAL_FILEP((unsigned int)offset, stream, FD_API_OTHER,
"%p, %ld, %d", stream, offset, origin);
{
static int (*fsetposp)(FILE* stream, const fpos_t* pos);
- BEFORE_ORIGINAL_FILE(fsetpos, libc.so.6);
+ BEFORE_ORIGINAL_FILE(fsetpos, LIBC);
ret = fsetposp(stream, pos);
AFTER_ORIGINAL_FILEP(0, stream, FD_API_OTHER, "%p, %p", stream, pos);
return ret;
static long int (*ftellp)(FILE* stream);
long int lret;
- BEFORE_ORIGINAL_FILE(ftell, libc.so.6);
+ BEFORE_ORIGINAL_FILE(ftell, LIBC);
lret = ftellp(stream);
{
static void (*rewindp)(FILE* stream);
- BEFORE_ORIGINAL_FILE(rewind, libc.so.6);
+ BEFORE_ORIGINAL_FILE(rewind, LIBC);
rewindp(stream);
{
static void (*clearerrp)(FILE* stream);
- BEFORE_ORIGINAL_FILE(clearerr, libc.so.6);
+ BEFORE_ORIGINAL_FILE(clearerr, LIBC);
clearerrp(stream);
{
static int (*feofp)(FILE* stream);
- BEFORE_ORIGINAL_FILE(feof, libc.so.6);
+ BEFORE_ORIGINAL_FILE(feof, LIBC);
ret = feofp(stream);
AFTER_ORIGINAL_FILEP(0, stream, FD_API_OTHER, "%p", stream);
return ret;
{
static int (*ferrorp)(FILE* stream);
- BEFORE_ORIGINAL_FILE(ferror, libc.so.6);
+ BEFORE_ORIGINAL_FILE(ferror, LIBC);
ret = ferrorp(stream);
AFTER_ORIGINAL_FILEP(0, stream, FD_API_OTHER, "%p", stream);
return ret;
{
static int (*filenop)(FILE* stream);
- BEFORE_ORIGINAL_FILE(fileno, libc.so.6);
+ BEFORE_ORIGINAL_FILE(fileno, LIBC);
ret = filenop(stream);
AFTER_ORIGINAL_FILEP(0, stream, FD_API_OTHER, "%p", stream);
return ret;
{
static void (*perrorp)(const char* string);
- BEFORE_ORIGINAL_FILE(perror, libc.so.6);
+ BEFORE_ORIGINAL_FILE(perror, LIBC);
perrorp(string);
{
static int (*vfprintfp)(FILE* stream, const char* format, va_list arg);
- BEFORE_ORIGINAL_FILE(vfprintf, libc.so.6);
+ BEFORE_ORIGINAL_FILE(vfprintf, LIBC);
ret = vfprintfp(stream, format, arg);
AFTER_ORIGINAL_FILEP(ret, stream, FD_API_WRITE, "%p, %s", stream, format);
return ret;
{
static int (*vfscanfp)(FILE* stream, const char* format, va_list arg);
- BEFORE_ORIGINAL_FILE(vfscanf, libc.so.6);
+ BEFORE_ORIGINAL_FILE(vfscanf, LIBC);
ret = vfscanfp(stream, format, arg);
AFTER_ORIGINAL_FILEP(ret, stream, FD_API_READ, "%p, %s", stream, format);
return ret;
{
static int (*fgetcp)(FILE* stream);
- BEFORE_ORIGINAL_FILE(fgetc, libc.so.6);
+ BEFORE_ORIGINAL_FILE(fgetc, LIBC);
ret = fgetcp(stream);
AFTER_ORIGINAL_FILEP((ret == EOF ? 0 : 1), stream, FD_API_READ, "%p", stream);
return ret;
static char* (*fgetsp)(char* str, int num, FILE* stream);
char* cret;
- BEFORE_ORIGINAL_FILE(fgets, libc.so.6);
+ BEFORE_ORIGINAL_FILE(fgets, LIBC);
cret = fgetsp(str, size, stream);
{
static int (*fputcp)(int character, FILE* stream);
- BEFORE_ORIGINAL_FILE(fputc, libc.so.6);
+ BEFORE_ORIGINAL_FILE(fputc, LIBC);
ret = fputcp(character, stream);
AFTER_ORIGINAL_FILEP((ret == EOF ? 0 : 1), stream, FD_API_WRITE,
"%d, %p", character, stream);
{
static int (*fputsp)(const char* str, FILE* stream);
- BEFORE_ORIGINAL_FILE(fputs, libc.so.6);
+ BEFORE_ORIGINAL_FILE(fputs, LIBC);
ret = fputsp(str, stream);
AFTER_ORIGINAL_FILEP(ret, stream, FD_API_WRITE, "%s, %p", str, stream);
return ret;
{
static int (*getcp)(FILE* stream);
- BEFORE_ORIGINAL_FILE(getc, libc.so.6);
+ BEFORE_ORIGINAL_FILE(getc, LIBC);
ret = getcp(stream);
AFTER_ORIGINAL_FILEP((ret == EOF ? 0 : 1), stream, FD_API_READ, "%p", stream);
return ret;
{
static int (*putcp)(int character, FILE* stream);
- BEFORE_ORIGINAL_FILE(putc, libc.so.6);
+ BEFORE_ORIGINAL_FILE(putc, LIBC);
ret = putcp(character, stream);
AFTER_ORIGINAL_FILEP((ret == EOF ? 0 : 1), stream, FD_API_WRITE,
"%d, %p", character, stream);
{
static int (*ungetcp)(int character, FILE* stream);
- BEFORE_ORIGINAL_FILE(ungetc, libc.so.6);
+ BEFORE_ORIGINAL_FILE(ungetc, LIBC);
ret = ungetcp(character, stream);
AFTER_ORIGINAL_FILEP(0, stream, FD_API_OTHER, "%d, %p", character, stream);
return ret;
static size_t (*freadp)(void* ptr, size_t size, size_t count, FILE* stream);
size_t tret;
- BEFORE_ORIGINAL_FILE(fread, libc.so.6);
+ BEFORE_ORIGINAL_FILE(fread, LIBC);
tret = freadp(ptr, size, count, stream);
static size_t (*fwritep)(const void* ptr, size_t size, size_t count, FILE* stream);
size_t tret;
- BEFORE_ORIGINAL_FILE(fwrite, libc.so.6);
+ BEFORE_ORIGINAL_FILE(fwrite, LIBC);
tret = fwritep(ptr, size, count, stream);
{
static int (*vfprintfp)(FILE* stream, const char* format, ...);
- BEFORE_ORIGINAL_FILE(vfprintf, libc.so.6);
+ BEFORE_ORIGINAL_FILE(vfprintf, LIBC);
va_list arg;
va_start(arg, format);
{
static int (*vfscanfp)(FILE* stream, const char* format, ...);
- BEFORE_ORIGINAL_FILE(vfscanf, libc.so.6);
+ BEFORE_ORIGINAL_FILE(vfscanf, LIBC);
va_list arg;
va_start(arg, format);
{
static int (*vprintfp)(const char* format, ...);
- BEFORE_ORIGINAL_FILE(vprintf, libc.so.6);
+ BEFORE_ORIGINAL_FILE(vprintf, LIBC);
va_list arg;
va_start(arg, format);
{
static int (*vscanfp)(const char* format, ...);
- BEFORE_ORIGINAL_FILE(vscanf, libc.so.6);
+ BEFORE_ORIGINAL_FILE(vscanf, LIBC);
va_list arg;
va_start(arg, format);
{
static int (*getcharp)();
- BEFORE_ORIGINAL_FILE(getchar, libc.so.6);
+ BEFORE_ORIGINAL_FILE(getchar, LIBC);
ret = getcharp();
AFTER_ORIGINAL_NOFD((ret == EOF ? 0 : 1), FD_API_READ, "%s", "");
return ret;
{
static int (*putcharp)(int c);
- BEFORE_ORIGINAL_FILE(putchar, libc.so.6);
+ BEFORE_ORIGINAL_FILE(putchar, LIBC);
ret = putcharp(c);
AFTER_ORIGINAL_NOFD((ret == EOF ? 0 : 1), FD_API_WRITE, "%d", c);
return ret;
static char* (*getsp)(char* str);
char* cret;
- BEFORE_ORIGINAL_FILE(gets, libc.so.6);
+ BEFORE_ORIGINAL_FILE(gets, LIBC);
cret = getsp(str);
{
static int (*putsp)(const char* str);
- BEFORE_ORIGINAL_FILE(puts, libc.so.6);
+ BEFORE_ORIGINAL_FILE(puts, LIBC);
ret = putsp(str);
AFTER_ORIGINAL_NOFD(ret, FD_API_WRITE, "%s", str);
return ret;
static char* (*tmpnamp)(char* str);
char* cret;
- BEFORE_ORIGINAL_FILE(tmpnam, libc.so.6);
+ BEFORE_ORIGINAL_FILE(tmpnam, LIBC);
cret = tmpnamp(str);
{
static void (*setbufp)(FILE* stream, char* buf);
- BEFORE_ORIGINAL_FILE(setbuf, libc.so.6);
+ BEFORE_ORIGINAL_FILE(setbuf, LIBC);
setbufp(stream, buf);
{
static void (*setbufferp)(FILE* stream, char* buf, size_t size);
- BEFORE_ORIGINAL_FILE(setbuffer, libc.so.6);
+ BEFORE_ORIGINAL_FILE(setbuffer, LIBC);
setbufferp(stream, buf, size);
{
static int (*setlinebufp)(FILE* stream);
- BEFORE_ORIGINAL_FILE(setlinebuf, libc.so.6);
+ BEFORE_ORIGINAL_FILE(setlinebuf, LIBC);
setlinebufp(stream);
{
static int (*setvbufp)(FILE* stream, char* buf, int mode, size_t size);
- BEFORE_ORIGINAL_FILE(setvbuf, libc.so.6);
+ BEFORE_ORIGINAL_FILE(setvbuf, LIBC);
ret = setvbufp(stream,buf,mode,size);
AFTER_ORIGINAL_FILEP(size, stream, FD_API_OTHER,
"%p, %p, %d, %u", stream, buf, mode, size);
#include "daprobe.h"
#include "probeinfo.h"
#include "dautil.h"
+#include "dahelper.h"
#include "da_socket.h"
static enum DaOptions _sopt = OPT_FILE;
{
static int (*socketp)(int domain, int type, int protocol);
- BEFORE_ORIGINAL_NOFILTER(socket, libc.so.6);
+ BEFORE_ORIGINAL_NOFILTER(socket, LIBC);
ret = socketp(domain, type, protocol);
{
static int (*socketpairp)(int domain, int type, int protocol,int socket_vector[2]);
- BEFORE_ORIGINAL_NOFILTER(socketpair, libc.so.6);
+ BEFORE_ORIGINAL_NOFILTER(socketpair, LIBC);
ret = socketpairp(domain, type, protocol, socket_vector);
{
static int (*shutdownp)(int socket, int how);
- BEFORE_ORIGINAL_NOFILTER(shutdown, libc.so.6);
+ BEFORE_ORIGINAL_NOFILTER(shutdown, LIBC);
ret = shutdownp(socket, how);
{
static int (*bindp)(int socket, const struct sockaddr *address, socklen_t address_len);
- BEFORE_ORIGINAL(bind, libc.so.6);
+ BEFORE_ORIGINAL(bind, LIBC);
ret = bindp(socket, address, address_len);
{
static int (*listenp)(int socket, int backlog);
- BEFORE_ORIGINAL(listen, libc.so.6);
+ BEFORE_ORIGINAL(listen, LIBC);
ret = listenp(socket, backlog);
{
static int (*acceptp)(int socket, struct sockaddr *address, socklen_t *address_len);
- BEFORE_ORIGINAL_NOFILTER(accept, libc.so.6);
+ BEFORE_ORIGINAL_NOFILTER(accept, LIBC);
ret = acceptp(socket, address, address_len);
{
static int (*accept4p)(int sockfd, struct sockaddr *addr, socklen_t *addrlen, int flags);
- BEFORE_ORIGINAL_NOFILTER(accept4, libc.so.6);
+ BEFORE_ORIGINAL_NOFILTER(accept4, LIBC);
ret = accept4p(sockfd, addr, addrlen, flags);
{
static int (*connectp)(int socket, const struct sockaddr *address, socklen_t address_len);
- BEFORE_ORIGINAL(connect, libc.so.6);
+ BEFORE_ORIGINAL(connect, LIBC);
ret = connectp(socket, address, address_len);
{
static int (*selectp)(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);
- BEFORE_ORIGINAL(select, libc.so.6);
+ BEFORE_ORIGINAL(select, LIBC);
ret = selectp(nfds, readfds, writefds,exceptfds, timeout);
{
static int (*pselectp)(int nfds, fd_set *readfds, fd_set *writefds,fd_set *exceptfds, const struct timespec *ntimeout, const sigset_t *sigmask);
- BEFORE_ORIGINAL(pselect, libc.so.6);
+ BEFORE_ORIGINAL(pselect, LIBC);
ret = pselectp(nfds, readfds, writefds,exceptfds, ntimeout, sigmask);
static ssize_t (*sendp)(int socket, const void *message, size_t length, int flags);
ssize_t sret;
- BEFORE_ORIGINAL(send, libc.so.6);
+ BEFORE_ORIGINAL(send, LIBC);
sret = sendp(socket, message, length, flags);
static ssize_t (*sendmsgp)(int socket, const struct msghdr *message, int flags);
ssize_t sret;
- BEFORE_ORIGINAL(sendmsg, libc.so.6);
+ BEFORE_ORIGINAL(sendmsg, LIBC);
sret = sendmsgp(socket, message, flags);
static ssize_t (*sendtop)(int socket, const void *message, size_t length, int flags,const struct sockaddr *dest_addr, socklen_t dest_len);
ssize_t sret;
- BEFORE_ORIGINAL(sendto, libc.so.6);
+ BEFORE_ORIGINAL(sendto, LIBC);
sret = sendtop(socket, message, length, flags, dest_addr, dest_len);
static ssize_t (*recvp)(int socket, void *buffer, size_t length, int flags);
ssize_t sret;
- BEFORE_ORIGINAL(recv, libc.so.6);
+ BEFORE_ORIGINAL(recv, LIBC);
sret = recvp(socket, buffer, length, flags);
static ssize_t (*recvfromp)(int socket, void *buffer, size_t length, int flags, struct sockaddr *address, socklen_t *address_len);
ssize_t sret;
- BEFORE_ORIGINAL(recvfrom, libc.so.6);
+ BEFORE_ORIGINAL(recvfrom, LIBC);
sret = recvfromp(socket, buffer, length, flags, address, address_len);
static ssize_t (*recvmsgp)(int socket, struct msghdr *message, int flags);
ssize_t sret;
- BEFORE_ORIGINAL(recvmsg, libc.so.6);
+ BEFORE_ORIGINAL(recvmsg, LIBC);
sret = recvmsgp(socket, message, flags);
static uint32_t (*htonlp)(uint32_t hostlong);
uint32_t uret;
- BEFORE_ORIGINAL(htonl, libc.so.6);
+ BEFORE_ORIGINAL(htonl, LIBC);
uret = htonlp(hostlong);
static uint16_t (*htonsp)(uint16_t hostshort);
uint16_t uret;
- BEFORE_ORIGINAL(htons, libc.so.6);
+ BEFORE_ORIGINAL(htons, LIBC);
uret = htonsp(hostshort);
static uint32_t (*ntohlp)(uint32_t netlong);
uint32_t uret;
- BEFORE_ORIGINAL(ntohl, libc.so.6);
+ BEFORE_ORIGINAL(ntohl, LIBC);
uret = ntohlp(netlong);
static uint16_t (*ntohsp)(uint16_t netshort);
uint16_t uret;
- BEFORE_ORIGINAL(ntohs, libc.so.6);
+ BEFORE_ORIGINAL(ntohs, LIBC);
uret = ntohsp(netshort);
static uint16_t (*htobe16p)(uint16_t host_16bits);
uint16_t uret;
- BEFORE_ORIGINAL(htobe16, libc.so.6);
+ BEFORE_ORIGINAL(htobe16, LIBC);
uret = htobe16p(host_16bits);
static uint16_t (*htole16p)(uint16_t host_16bits);
uint16_t uret;
- BEFORE_ORIGINAL(htole16, libc.so.6);
+ BEFORE_ORIGINAL(htole16, LIBC);
uret = htole16p(host_16bits);
static uint16_t (*be16tohp)(uint16_t big_endian_16bits);
uint16_t uret;
- BEFORE_ORIGINAL(be16toh, libc.so.6);
+ BEFORE_ORIGINAL(be16toh, LIBC);
uret = be16tohp(big_endian_16bits);
static uint16_t (*le16tohp)(uint16_t little_endian_16bits);
uint16_t uret;
- BEFORE_ORIGINAL(le16toh, libc.so.6);
+ BEFORE_ORIGINAL(le16toh, LIBC);
uret = le16tohp(little_endian_16bits);
static uint32_t (*htobe32p)(uint32_t host_32bits);
uint32_t uret;
- BEFORE_ORIGINAL(htobe32, libc.so.6);
+ BEFORE_ORIGINAL(htobe32, LIBC);
uret = htobe32p(host_32bits);
static uint32_t (*htole32p)(uint32_t host_32bits);
uint32_t uret;
- BEFORE_ORIGINAL(htole32, libc.so.6);
+ BEFORE_ORIGINAL(htole32, LIBC);
uret = htole32p(host_32bits);
static uint32_t (*be32tohp)(uint32_t big_endian_32bits);
uint32_t uret;
- BEFORE_ORIGINAL(be32toh, libc.so.6);
+ BEFORE_ORIGINAL(be32toh, LIBC);
uret = be32tohp(big_endian_32bits);
static uint32_t (*le32tohp)(uint32_t little_endian_32bits);
uint32_t uret;
- BEFORE_ORIGINAL(le32toh, libc.so.6);
+ BEFORE_ORIGINAL(le32toh, LIBC);
uret = le32tohp(little_endian_32bits);
static uint64_t (*htobe64p)(uint64_t host_64bits);
uint64_t uret;
- BEFORE_ORIGINAL(htobe64, libc.so.6);
+ BEFORE_ORIGINAL(htobe64, LIBC);
uret = htobe64p(host_64bits);
static uint64_t (*htole64p)(uint64_t host_64bits);
uint64_t uret;
- BEFORE_ORIGINAL(htole64, libc.so.6);
+ BEFORE_ORIGINAL(htole64, LIBC);
uret = htole64p(host_64bits);
static uint64_t (*be64tohp)(uint64_t big_endian_64bits);
uint64_t uret;
- BEFORE_ORIGINAL(be64toh, libc.so.6);
+ BEFORE_ORIGINAL(be64toh, LIBC);
uret = be64tohp(big_endian_64bits);
static uint64_t (*le64tohp)(uint64_t little_endian_64bits);
uint64_t uret;
- BEFORE_ORIGINAL(le64toh, libc.so.6);
+ BEFORE_ORIGINAL(le64toh, LIBC);
uret = le64tohp(little_endian_64bits);
{
static int (*inet_atonp)(const char *cp, struct in_addr *inp);
- BEFORE_ORIGINAL(inet_aton, libc.so.6);
+ BEFORE_ORIGINAL(inet_aton, LIBC);
ret = inet_atonp(cp,inp);
static in_addr_t (*inet_addrp)(const char *cp);
in_addr_t iret;
- BEFORE_ORIGINAL(inet_addr, libc.so.6);
+ BEFORE_ORIGINAL(inet_addr, LIBC);
iret = inet_addrp(cp);
static in_addr_t (*inet_networkp)(const char *cp);
in_addr_t iret;
- BEFORE_ORIGINAL(inet_network, libc.so.6);
+ BEFORE_ORIGINAL(inet_network, LIBC);
iret = inet_networkp(cp);
static char * (*inet_ntoap)(struct in_addr in);
char* sret;
- BEFORE_ORIGINAL(inet_ntoa, libc.so.6);
+ BEFORE_ORIGINAL(inet_ntoa, LIBC);
sret = inet_ntoap(in);
static struct in_addr (*inet_makeaddrp)(int net, int host);
struct in_addr iret;
- BEFORE_ORIGINAL(inet_makeaddr, libc.so.6);
+ BEFORE_ORIGINAL(inet_makeaddr, LIBC);
iret = inet_makeaddrp(net,host);
static in_addr_t (*inet_lnaofp)(struct in_addr in);
in_addr_t iret;
- BEFORE_ORIGINAL(inet_lnaof, libc.so.6);
+ BEFORE_ORIGINAL(inet_lnaof, LIBC);
iret = inet_lnaofp(in);
static in_addr_t (*inet_netofp)(struct in_addr in);
in_addr_t iret;
- BEFORE_ORIGINAL(inet_netof, libc.so.6);
+ BEFORE_ORIGINAL(inet_netof, LIBC);
iret = inet_netofp(in);
static const char* (*inet_ntopp)(int af, const void *src, char *dst, socklen_t size);
const char* cret;
- BEFORE_ORIGINAL(inet_ntop, libc.so.6);
+ BEFORE_ORIGINAL(inet_ntop, LIBC);
cret = inet_ntopp(af, src, dst, size);
{
static int (*inet_ptonp)(int af, const char *src, void *dst);
- BEFORE_ORIGINAL(inet_pton, libc.so.6);
+ BEFORE_ORIGINAL(inet_pton, LIBC);
ret = inet_ptonp(af, src, dst);
{
static int (*getaddrinfop)(const char *node, const char *service, const struct addrinfo *hints, struct addrinfo **res);
- BEFORE_ORIGINAL_NOFILTER(getaddrinfo, libc.so.6);
+ BEFORE_ORIGINAL_NOFILTER(getaddrinfo, LIBC);
ret = getaddrinfop(node, service, hints, res);
{
static void (*freeaddrinfop)(struct addrinfo *res);
- BEFORE_ORIGINAL_NOFILTER(freeaddrinfo, libc.so.6);
+ BEFORE_ORIGINAL_NOFILTER(freeaddrinfo, LIBC);
freeaddrinfop(res);
static const char * (*gai_strerrorp)(int errcode);
const char * cret;
- BEFORE_ORIGINAL(gai_strerror, libc.so.6);
+ BEFORE_ORIGINAL(gai_strerror, LIBC);
cret = gai_strerrorp(errcode);
{
static int (*gai_suspendp)(const struct gaicb* const list[], int nitems, const struct timespec *timeout);
- BEFORE_ORIGINAL(gai_suspend, libc.so.6);
+ BEFORE_ORIGINAL(gai_suspend, LIBC);
ret = gai_suspendp(list,nitems,timeout);
{
static int (*gai_errorp)(struct gaicb *req);
- BEFORE_ORIGINAL(gai_error, libc.so.6);
+ BEFORE_ORIGINAL(gai_error, LIBC);
ret = gai_errorp(req);
{
static int (*gai_cancelp)(struct gaicb *req);
- BEFORE_ORIGINAL(gai_cancel, libc.so.6);
+ BEFORE_ORIGINAL(gai_cancel, LIBC);
ret = gai_cancelp(req);
{
static int (*getaddrinfo_ap)(int mode, struct gaicb *list[], int nitems, struct sigevent *sevp);
- BEFORE_ORIGINAL(getaddrinfo_a, libc.so.6);
+ BEFORE_ORIGINAL(getaddrinfo_a, LIBC);
ret = getaddrinfo_ap(mode, list,nitems, sevp);
{
static int (*getsockoptp)(int socket, int level, int option_name, void *option_value, socklen_t *option_len);
- BEFORE_ORIGINAL(getsockopt, libc.so.6);
+ BEFORE_ORIGINAL(getsockopt, LIBC);
ret = getsockoptp(socket, level, option_name, option_value, option_len);
{
static int (*setsockoptp)(int socket, int level, int option_name, const void *option_value, socklen_t option_len);
- BEFORE_ORIGINAL(setsockopt, libc.so.6);
+ BEFORE_ORIGINAL(setsockopt, LIBC);
ret = setsockoptp(socket, level, option_name, option_value, option_len);
{
static int (*getsocknamep)(int sockfd, struct sockaddr *addr, socklen_t *addrlen );
- BEFORE_ORIGINAL(getsockname, libc.so.6);
+ BEFORE_ORIGINAL(getsockname, LIBC);
ret = getsocknamep(sockfd, addr, addrlen);
{
static int (*getdomainnamep)(char *name, size_t len);
- BEFORE_ORIGINAL(getdomainname, libc.so.6);
+ BEFORE_ORIGINAL(getdomainname, LIBC);
ret = getdomainnamep(name, len);
{
static int (*setdomainnamep)(const char *name, size_t len);
- BEFORE_ORIGINAL(setdomainname, libc.so.6);
+ BEFORE_ORIGINAL(setdomainname, LIBC);
ret = setdomainnamep(name, len);
{
static int (*gethostnamep)(char *name, size_t len);
- BEFORE_ORIGINAL(gethostname, libc.so.6);
+ BEFORE_ORIGINAL(gethostname, LIBC);
ret = gethostnamep(name, len);
{
static int (*sethostnamep)(const char *name, size_t len);
- BEFORE_ORIGINAL(sethostname, libc.so.6);
+ BEFORE_ORIGINAL(sethostname, LIBC);
ret = sethostnamep(name, len);
{
static int (*getpeernamep)(int s, struct sockaddr *addr, socklen_t *len);
- BEFORE_ORIGINAL(getpeername, libc.so.6);
+ BEFORE_ORIGINAL(getpeername, LIBC);
ret = getpeernamep(s, addr, len);
{
static int (*getnameinfop)(const struct sockaddr *sa, socklen_t salen, char *host, socklen_t hostlen, char *serv, socklen_t servlen, unsigned int flags);
- BEFORE_ORIGINAL(getnameinfo, libc.so.6);
+ BEFORE_ORIGINAL(getnameinfo, LIBC);
ret = getnameinfop(sa, salen,host, hostlen, serv, servlen, flags);
static struct hostent * (*gethostbynamep)(const char *name);
struct hostent* pret;
- BEFORE_ORIGINAL(gethostbyname, libc.so.6);
+ BEFORE_ORIGINAL(gethostbyname, LIBC);
pret = gethostbynamep(name);
static struct hostent * (*gethostbyaddrp)(const void *addr, socklen_t len, int type);
struct hostent* pret;
- BEFORE_ORIGINAL(gethostbyaddr, libc.so.6);
+ BEFORE_ORIGINAL(gethostbyaddr, LIBC);
pret = gethostbyaddrp(addr, len, type);
{
static void (*sethostentp)(int stayopen);
- BEFORE_ORIGINAL(sethostent, libc.so.6);
+ BEFORE_ORIGINAL(sethostent, LIBC);
sethostentp(stayopen);
{
static void (*endhostentp)(void);
- BEFORE_ORIGINAL(endhostent, libc.so.6);
+ BEFORE_ORIGINAL(endhostent, LIBC);
endhostentp();
{
static void (*herrorp)(const char *s);
- BEFORE_ORIGINAL(herror, libc.so.6);
+ BEFORE_ORIGINAL(herror, LIBC);
herrorp(s);
static const char* (*hstrerrorp)(int err);
const char* cret;
- BEFORE_ORIGINAL(hstrerror, libc.so.6);
+ BEFORE_ORIGINAL(hstrerror, LIBC);
cret = hstrerrorp(err);
static struct hostent* (*gethostentp)(void);
struct hostent* pret;
- BEFORE_ORIGINAL(gethostent, libc.so.6);
+ BEFORE_ORIGINAL(gethostent, LIBC);
pret = gethostentp();
static struct hostent * (*gethostbyname2p)(const char *name, int af);
struct hostent* pret;
- BEFORE_ORIGINAL(gethostbyname2, libc.so.6);
+ BEFORE_ORIGINAL(gethostbyname2, LIBC);
pret = gethostbyname2p(name, af);
{
static int (*gethostent_rp)(struct hostent *rret, char *buf, size_t buflen, struct hostent **result, int *h_errnop);
- BEFORE_ORIGINAL(gethostent_r, libc.so.6);
+ BEFORE_ORIGINAL(gethostent_r, LIBC);
ret = gethostent_rp(rret, buf, buflen, result, h_errnop);
{
static int (*gethostbyaddr_rp)(const void *addr, socklen_t len, int type, struct hostent *rret, char *buf, size_t buflen, struct hostent **result, int *h_errnop);
- BEFORE_ORIGINAL(gethostbyaddr_r, libc.so.6);
+ BEFORE_ORIGINAL(gethostbyaddr_r, LIBC);
ret = gethostbyaddr_rp(addr, len, type, rret, buf, buflen, result, h_errnop);
{
static int (*gethostbyname_rp)(const char *name, struct hostent *rret, char *buf, size_t buflen, struct hostent **result, int *h_errnop);
- BEFORE_ORIGINAL(gethostbyname_r, libc.so.6);
+ BEFORE_ORIGINAL(gethostbyname_r, LIBC);
ret = gethostbyname_rp(name, rret, buf, buflen, result, h_errnop);
{
static int (*gethostbyname2_rp)(const char *name, int af, struct hostent *rret, char *buf, size_t buflen, struct hostent **result, int *h_errnop);
- BEFORE_ORIGINAL(gethostbyname2_r, libc.so.6);
+ BEFORE_ORIGINAL(gethostbyname2_r, LIBC);
ret = gethostbyname2_rp(name, af, rret, buf, buflen, result, h_errnop);
static struct servent * (*getservbynamep)(const char *name, const char *proto);
struct servent* pret;
- BEFORE_ORIGINAL(getservbyname, libc.so.6);
+ BEFORE_ORIGINAL(getservbyname, LIBC);
pret = getservbynamep(name, proto);
{
static void (*setserventp)(int stayopen);
- BEFORE_ORIGINAL(setservent, libc.so.6);
+ BEFORE_ORIGINAL(setservent, LIBC);
setserventp(stayopen);
{
static void (*endserventp)(void);
- BEFORE_ORIGINAL(endservent, libc.so.6);
+ BEFORE_ORIGINAL(endservent, LIBC);
endserventp();
static struct servent * (*getserventp)(void);
struct servent* pret;
- BEFORE_ORIGINAL(getservent, libc.so.6);
+ BEFORE_ORIGINAL(getservent, LIBC);
pret = getserventp();
static struct servent * (*getservbyportp)(int port, const char *proto);
struct servent* pret;
- BEFORE_ORIGINAL(getservbyport, libc.so.6);
+ BEFORE_ORIGINAL(getservbyport, LIBC);
pret = getservbyportp(port, proto);
{
static int (*getservent_rp)(struct servent *result_buf, char *buf, size_t buflen, struct servent **result);
- BEFORE_ORIGINAL(getservent_r, libc.so.6);
+ BEFORE_ORIGINAL(getservent_r, LIBC);
ret = getservent_rp(result_buf, buf, buflen, result);
{
static int (*getservbyname_rp)(const char *name, const char *proto, struct servent *result_buf, char *buf, size_t buflen, struct servent **result);
- BEFORE_ORIGINAL(getservbyname_r, libc.so.6);
+ BEFORE_ORIGINAL(getservbyname_r, LIBC);
ret = getservbyname_rp(name, proto, result_buf, buf, buflen, result);
{
static int (*getservbyport_rp)(int port, const char *proto, struct servent *result_buf, char *buf, size_t buflen, struct servent **result);
- BEFORE_ORIGINAL(getservbyport_r, libc.so.6);
+ BEFORE_ORIGINAL(getservbyport_r, LIBC);
ret = getservbyport_rp(port, proto, result_buf, buf, buflen, result);
static struct netent * (*getnetentp)(void);
struct netent* pret;
- BEFORE_ORIGINAL(getnetent, libc.so.6);
+ BEFORE_ORIGINAL(getnetent, LIBC);
pret = getnetentp();
static struct netent * (*getnetbynamep)(const char *name);
struct netent* pret;
- BEFORE_ORIGINAL(getnetbyname, libc.so.6);
+ BEFORE_ORIGINAL(getnetbyname, LIBC);
pret = getnetbynamep(name);
static struct netent * (*getnetbyaddrp)(uint32_t net, int type);
struct netent * pret;
- BEFORE_ORIGINAL(getnetbyaddr, libc.so.6);
+ BEFORE_ORIGINAL(getnetbyaddr, LIBC);
pret = getnetbyaddrp(net, type);
{
static void (*setnetentp)(int stayopen);
- BEFORE_ORIGINAL(setnetent, libc.so.6);
+ BEFORE_ORIGINAL(setnetent, LIBC);
setnetentp(stayopen);
{
static void (*endnetentp)(void);
- BEFORE_ORIGINAL(endnetent, libc.so.6);
+ BEFORE_ORIGINAL(endnetent, LIBC);
endnetentp();
{
static int (*getnetent_rp)(struct netent *result_buf, char *buf, size_t buflen, struct netent **result, int *h_errnop);
- BEFORE_ORIGINAL(getnetent_r, libc.so.6);
+ BEFORE_ORIGINAL(getnetent_r, LIBC);
ret = getnetent_rp(result_buf, buf, buflen, result, h_errnop);
{
static int (*getnetbyname_rp)(const char *name, struct netent *result_buf, char *buf, size_t buflen, struct netent **result, int *h_errnop);
- BEFORE_ORIGINAL(getnetbyname_r, libc.so.6);
+ BEFORE_ORIGINAL(getnetbyname_r, LIBC);
ret = getnetbyname_rp(name,result_buf, buf, buflen, result, h_errnop);
{
static int (*getnetbyaddr_rp)(uint32_t net, int type, struct netent *result_buf, char *buf, size_t buflen, struct netent **result, int *h_errnop);
- BEFORE_ORIGINAL(getnetbyaddr_r, libc.so.6);
+ BEFORE_ORIGINAL(getnetbyaddr_r, LIBC);
ret = getnetbyaddr_rp(net, type, result_buf, buf, buflen, result, h_errnop);
static struct protoent * (*getprotoentp)(void);
struct protoent * pret;
- BEFORE_ORIGINAL(getprotoent, libc.so.6);
+ BEFORE_ORIGINAL(getprotoent, LIBC);
pret = getprotoentp();
static struct protoent * (*getprotobynamep)(const char *name);
struct protoent * pret;
- BEFORE_ORIGINAL(getprotobyname, libc.so.6);
+ BEFORE_ORIGINAL(getprotobyname, LIBC);
pret = getprotobynamep(name);
static struct protoent * (*getprotobynumberp)(int proto);
struct protoent * pret;
- BEFORE_ORIGINAL(getprotobynumber, libc.so.6);
+ BEFORE_ORIGINAL(getprotobynumber, LIBC);
pret = getprotobynumberp(proto);
{
static void (*setprotoentp)(int stayopen);
- BEFORE_ORIGINAL(setprotoent, libc.so.6);
+ BEFORE_ORIGINAL(setprotoent, LIBC);
setprotoentp(stayopen);
{
static void (*endprotoentp)(void);
- BEFORE_ORIGINAL(endprotoent, libc.so.6);
+ BEFORE_ORIGINAL(endprotoent, LIBC);
endprotoentp();
{
static int (*getprotoent_rp)(struct protoent *result_buf, char *buf, size_t buflen, struct protoent **result);
- BEFORE_ORIGINAL(getprotoent_r, libc.so.6);
+ BEFORE_ORIGINAL(getprotoent_r, LIBC);
ret = getprotoent_rp(result_buf, buf, buflen, result);
{
static int (*getprotobyname_rp)(const char *name, struct protoent *result_buf, char *buf, size_t buflen, struct protoent **result);
- BEFORE_ORIGINAL(getprotobyname_r, libc.so.6);
+ BEFORE_ORIGINAL(getprotobyname_r, LIBC);
ret = getprotobyname_rp(name, result_buf, buf, buflen, result);
{
static int (*getprotobynumber_rp)(int proto, struct protoent *result_buf, char *buf, size_t buflen, struct protoent **result);
- BEFORE_ORIGINAL(getprotobynumber_r, libc.so.6);
+ BEFORE_ORIGINAL(getprotobynumber_r, LIBC);
ret = getprotobynumber_rp(proto, result_buf, buf, buflen, result);
static unsigned int (*if_nametoindexp)(__const char *__ifname);
unsigned int uret;
- BEFORE_ORIGINAL(if_nametoindex, libc.so.6);
+ BEFORE_ORIGINAL(if_nametoindex, LIBC);
uret = if_nametoindexp(__ifname);
static char * (*if_indextonamep)(unsigned int __ifindex, char *__ifname);
char * cret;
- BEFORE_ORIGINAL(if_indextoname, libc.so.6);
+ BEFORE_ORIGINAL(if_indextoname, LIBC);
cret = if_indextonamep(__ifindex, __ifname);
static struct if_nameindex * (*if_nameindexp)(void);
struct if_nameindex * pret;
- BEFORE_ORIGINAL_NOFILTER(if_nameindex, libc.so.6);
+ BEFORE_ORIGINAL_NOFILTER(if_nameindex, LIBC);
pret = if_nameindexp();
{
static void (*if_freenameindexp)(struct if_nameindex *__ptr);
- BEFORE_ORIGINAL_NOFILTER(if_freenameindex, libc.so.6);
+ BEFORE_ORIGINAL_NOFILTER(if_freenameindex, LIBC);
if_freenameindexp(__ptr);
{
static int (*getifaddrsp)(struct ifaddrs **ifap);
- BEFORE_ORIGINAL_NOFILTER(getifaddrs, libc.so.6);
+ BEFORE_ORIGINAL_NOFILTER(getifaddrs, LIBC);
ret = getifaddrsp(ifap);
{
static void (*freeifaddrsp)(struct ifaddrs *ifa);
- BEFORE_ORIGINAL_NOFILTER(freeifaddrs, libc.so.6);
+ BEFORE_ORIGINAL_NOFILTER(freeifaddrs, LIBC);
freeifaddrsp(ifa);
{
static int (*pollp)(struct pollfd *ufds, unsigned int nfds, int timeout);
- BEFORE_ORIGINAL(poll, libc.so.6);
+ BEFORE_ORIGINAL(poll, LIBC);
ret = pollp(ufds, nfds, timeout);
{
static int (*ppollp)(struct pollfd *fds, nfds_t nfds, const struct timespec *timeout_ts, const sigset_t *sigmask);
- BEFORE_ORIGINAL(ppoll, libc.so.6);
+ BEFORE_ORIGINAL(ppoll, LIBC);
ret = ppollp(fds, nfds, timeout_ts, sigmask);
int i, saved_errno, ret;
int* fds;
- GET_REAL_FUNCP(daemon_close_allv, libdaemon.so.0, daemon_close_allvp);
+ GET_REAL_FUNCP(daemon_close_allv, LIBDAEMON, daemon_close_allvp);
probeBlockStart();
// get number of fds
static int (*pthread_mutex_initp)(pthread_mutex_t *mutex,
const pthread_mutexattr_t *attr);
- BEFORE_ORIGINAL_SYNC(pthread_mutex_init, libpthread.so.0);
+ BEFORE_ORIGINAL_SYNC(pthread_mutex_init, LIBPTHREAD);
ret = pthread_mutex_initp(mutex, attr);
int pthread_mutex_destroy(pthread_mutex_t *mutex) {
static int (*pthread_mutex_destroyp)(pthread_mutex_t *mutex);
- BEFORE_ORIGINAL_SYNC(pthread_mutex_destroy, libpthread.so.0);
+ BEFORE_ORIGINAL_SYNC(pthread_mutex_destroy, LIBPTHREAD);
ret = pthread_mutex_destroyp(mutex);
int real_pthread_mutex_lock(pthread_mutex_t *mutex) {
static int (*pthread_mutex_lockp)(pthread_mutex_t *mutex);
- GET_REAL_FUNC(pthread_mutex_lock, libpthread.so.0);
+ GET_REAL_FUNC(pthread_mutex_lock, LIBPTHREAD);
return pthread_mutex_lockp(mutex);
}
static int (*pthread_mutex_lockp)(pthread_mutex_t *mutex);
DECLARE_VARIABLE_STANDARD;
- GET_REAL_FUNC(pthread_mutex_lock, libpthread.so.0);
+ GET_REAL_FUNC(pthread_mutex_lock, LIBPTHREAD);
PRE_PROBEBLOCK_BEGIN();
// send WAIT_START log
const struct timespec *abs_timeout);
DECLARE_VARIABLE_STANDARD;
- GET_REAL_FUNC(pthread_mutex_timedlock, libpthread.so.0);
+ GET_REAL_FUNC(pthread_mutex_timedlock, LIBPTHREAD);
PRE_PROBEBLOCK_BEGIN();
// send WAIT_START log
int pthread_mutex_trylock(pthread_mutex_t *mutex) {
static int (*pthread_mutex_trylockp)(pthread_mutex_t *mutex);
- BEFORE_ORIGINAL_SYNC(pthread_mutex_trylock, libpthread.so.0);
+ BEFORE_ORIGINAL_SYNC(pthread_mutex_trylock, LIBPTHREAD);
ret = pthread_mutex_trylockp(mutex);
int real_pthread_mutex_unlock(pthread_mutex_t *mutex) {
static int (*pthread_mutex_unlockp)(pthread_mutex_t *mutex);
- GET_REAL_FUNC(pthread_mutex_unlock, libpthread.so.0);
+ GET_REAL_FUNC(pthread_mutex_unlock, LIBPTHREAD);
return pthread_mutex_unlockp(mutex);
}
int pthread_mutex_unlock(pthread_mutex_t *mutex) {
static int (*pthread_mutex_unlockp)(pthread_mutex_t *mutex);
- BEFORE_ORIGINAL_SYNC(pthread_mutex_unlock, libpthread.so.0);
+ BEFORE_ORIGINAL_SYNC(pthread_mutex_unlock, LIBPTHREAD);
ret = pthread_mutex_unlockp(mutex);
int pthread_mutexattr_init(pthread_mutexattr_t *attr) {
static int (*pthread_mutexattr_initp)(pthread_mutexattr_t *attr);
- BEFORE_ORIGINAL_SYNC(pthread_mutexattr_init, libpthread.so.0);
+ BEFORE_ORIGINAL_SYNC(pthread_mutexattr_init, LIBPTHREAD);
ret = pthread_mutexattr_initp(attr);
int pthread_mutexattr_destroy(pthread_mutexattr_t *attr) {
static int (*pthread_mutexattr_destroyp)(pthread_mutexattr_t *attr);
- BEFORE_ORIGINAL_SYNC(pthread_mutexattr_destroy, libpthread.so.0);
+ BEFORE_ORIGINAL_SYNC(pthread_mutexattr_destroy, LIBPTHREAD);
ret = pthread_mutexattr_destroyp(attr);
static int (*pthread_mutexattr_getprioceilingp)(
const pthread_mutexattr_t *attr, int *prioceiling);
- BEFORE_ORIGINAL_SYNC(pthread_mutexattr_getprioceiling, libpthread.so.0);
+ BEFORE_ORIGINAL_SYNC(pthread_mutexattr_getprioceiling, LIBPTHREAD);
ret = pthread_mutexattr_getprioceilingp(attr, prioceiling);
static int (*pthread_mutexattr_setprioceilingp)(
pthread_mutexattr_t *attr, int prioceiling);
- BEFORE_ORIGINAL_SYNC(pthread_mutexattr_setprioceiling, libpthread.so.0);
+ BEFORE_ORIGINAL_SYNC(pthread_mutexattr_setprioceiling, LIBPTHREAD);
ret = pthread_mutexattr_setprioceilingp(attr, prioceiling);
static int (*pthread_mutexattr_getprotocolp)(
const pthread_mutexattr_t *attr, int *protocol);
- BEFORE_ORIGINAL_SYNC(pthread_mutexattr_getprotocol, libpthread.so.0);
+ BEFORE_ORIGINAL_SYNC(pthread_mutexattr_getprotocol, LIBPTHREAD);
ret = pthread_mutexattr_getprotocolp(attr, protocol);
static int (*pthread_mutexattr_setprotocolp)(
pthread_mutexattr_t *attr, int protocol);
- BEFORE_ORIGINAL_SYNC(pthread_mutexattr_setprotocol, libpthread.so.0);
+ BEFORE_ORIGINAL_SYNC(pthread_mutexattr_setprotocol, LIBPTHREAD);
ret = pthread_mutexattr_setprotocolp(attr, protocol);
static int (*pthread_mutexattr_getpsharedp)(
const pthread_mutexattr_t *attr, int *pshared);
- BEFORE_ORIGINAL_SYNC(pthread_mutexattr_getpshared, libpthread.so.0);
+ BEFORE_ORIGINAL_SYNC(pthread_mutexattr_getpshared, LIBPTHREAD);
ret = pthread_mutexattr_getpsharedp(attr, pshared);
static int (*pthread_mutexattr_setpsharedp)(
pthread_mutexattr_t *attr, int pshared);
- BEFORE_ORIGINAL_SYNC(pthread_mutexattr_setpshared, libpthread.so.0);
+ BEFORE_ORIGINAL_SYNC(pthread_mutexattr_setpshared, LIBPTHREAD);
ret = pthread_mutexattr_setpsharedp(attr, pshared);
static int (*pthread_mutexattr_gettypep)(
const pthread_mutexattr_t *attr, int *type);
- BEFORE_ORIGINAL_SYNC(pthread_mutexattr_gettype, libpthread.so.0);
+ BEFORE_ORIGINAL_SYNC(pthread_mutexattr_gettype, LIBPTHREAD);
ret = pthread_mutexattr_gettypep(attr, type);
static int (*pthread_mutexattr_settypep)(
pthread_mutexattr_t *attr, int type);
- BEFORE_ORIGINAL_SYNC(pthread_mutexattr_settype, libpthread.so.0);
+ BEFORE_ORIGINAL_SYNC(pthread_mutexattr_settype, LIBPTHREAD);
ret = pthread_mutexattr_settypep(attr, type);
static int (*pthread_cond_initp)(pthread_cond_t *cond,
const pthread_condattr_t *attr);
- BEFORE_ORIGINAL_SYNC(pthread_cond_init, libpthread.so.0);
+ BEFORE_ORIGINAL_SYNC(pthread_cond_init, LIBPTHREAD);
ret = pthread_cond_initp(cond, attr);
int pthread_cond_destroy(pthread_cond_t *cond) {
static int (*pthread_cond_destroyp)(pthread_cond_t *cond);
- BEFORE_ORIGINAL_SYNC(pthread_cond_destroy, libpthread.so.0);
+ BEFORE_ORIGINAL_SYNC(pthread_cond_destroy, LIBPTHREAD);
ret = pthread_cond_destroyp(cond);
pthread_mutex_t *mutex);
DECLARE_VARIABLE_STANDARD;
- GET_REAL_FUNC(pthread_cond_wait, libpthread.so.0);
+ GET_REAL_FUNC(pthread_cond_wait, LIBPTHREAD);
PRE_PROBEBLOCK_BEGIN();
// send WAIT_START log
pthread_mutex_t *mutex, const struct timespec *abstime);
DECLARE_VARIABLE_STANDARD;
- GET_REAL_FUNC(pthread_cond_timedwait, libpthread.so.0);
+ GET_REAL_FUNC(pthread_cond_timedwait, LIBPTHREAD);
PRE_PROBEBLOCK_BEGIN();
// send WAIT_START log
int pthread_cond_signal(pthread_cond_t *cond) {
static int (*pthread_cond_signalp)(pthread_cond_t *cond);
- BEFORE_ORIGINAL_SYNC(pthread_cond_signal, libpthread.so.0);
+ BEFORE_ORIGINAL_SYNC(pthread_cond_signal, LIBPTHREAD);
ret = pthread_cond_signalp(cond);
int pthread_cond_broadcast(pthread_cond_t *cond) {
static int (*pthread_cond_broadcastp)(pthread_cond_t *cond);
- BEFORE_ORIGINAL_SYNC(pthread_cond_broadcast, libpthread.so.0);
+ BEFORE_ORIGINAL_SYNC(pthread_cond_broadcast, LIBPTHREAD);
ret = pthread_cond_broadcastp(cond);
static int (*pthread_createp)(pthread_t *thread,
const pthread_attr_t *attr, void *(*start_routine)(void *), void *arg);
- BEFORE_ORIGINAL_THREAD(pthread_create, libpthread.so.0);
+ BEFORE_ORIGINAL_THREAD(pthread_create, LIBPTHREAD);
if(blockresult)
{
static int (*pthread_joinp)(pthread_t thread, void **retval);
DECLARE_VARIABLE_STANDARD;
- GET_REAL_FUNC(pthread_join, libpthread.so.0);
+ GET_REAL_FUNC(pthread_join, LIBPTHREAD);
PRE_PROBEBLOCK_BEGIN();
// send WAIT_START log
static void (*pthread_exitp)(void *retval) __attribute__((noreturn));
DECLARE_VARIABLE_STANDARD;
- GET_REAL_FUNC(pthread_exit, libpthread.so.0);
+ GET_REAL_FUNC(pthread_exit, LIBPTHREAD);
PRE_PROBEBLOCK_BEGIN();
newerrno = 0;
{
static int (*pthread_cancelp)(pthread_t thread);
- BEFORE_ORIGINAL_THREAD(pthread_cancel, libpthread.so.0);
+ BEFORE_ORIGINAL_THREAD(pthread_cancel, LIBPTHREAD);
ret = pthread_cancelp(thread);
{
static int (*pthread_detachp)(pthread_t thread);
- BEFORE_ORIGINAL_THREAD(pthread_detach, libpthread.so.0);
+ BEFORE_ORIGINAL_THREAD(pthread_detach, LIBPTHREAD);
ret = pthread_detachp(thread);
pthread_t ret_pthr;
static pthread_t (*pthread_selfp)(void);
- BEFORE_ORIGINAL_THREAD(pthread_self, libpthread.so.0);
+ BEFORE_ORIGINAL_THREAD(pthread_self, LIBPTHREAD);
ret_pthr = pthread_selfp();
{
static int (*pthread_equalp)(pthread_t t1, pthread_t t2);
- BEFORE_ORIGINAL_THREAD(pthread_equal, libpthread.so.0);
+ BEFORE_ORIGINAL_THREAD(pthread_equal, LIBPTHREAD);
ret = pthread_equalp(t1, t2);
pthread_t pSelf;
static int (*pthread_setcancelstatep)(int state, int *oldstate);
- BEFORE_ORIGINAL_THREAD(pthread_setcancelstate, libpthread.so.0);
+ BEFORE_ORIGINAL_THREAD(pthread_setcancelstate, LIBPTHREAD);
pSelf = pthread_self();
ret = pthread_setcancelstatep(state, oldstate);
pthread_t pSelf;
static int (*pthread_setcanceltypep)(int type, int *oldtype);
- BEFORE_ORIGINAL_THREAD(pthread_setcanceltype, libpthread.so.0);
+ BEFORE_ORIGINAL_THREAD(pthread_setcanceltype, LIBPTHREAD);
pSelf = pthread_self();
ret = pthread_setcanceltypep(type, oldtype);
pthread_t thread = 0;
static int (*pthread_attr_initp)(pthread_attr_t *attr);
- BEFORE_ORIGINAL_THREAD(pthread_attr_init, libpthread.so.0);
+ BEFORE_ORIGINAL_THREAD(pthread_attr_init, LIBPTHREAD);
ret = pthread_attr_initp(attr);
pthread_t thread = 0;
static int (*pthread_attr_destroyp)(pthread_attr_t *attr);
- BEFORE_ORIGINAL_THREAD(pthread_attr_destroy, libpthread.so.0);
+ BEFORE_ORIGINAL_THREAD(pthread_attr_destroy, LIBPTHREAD);
ret = pthread_attr_destroyp(attr);
static int (*pthread_attr_getdetachstatep)(const pthread_attr_t *attr,
int *detachstate);
- BEFORE_ORIGINAL_THREAD(pthread_attr_getdetachstate, libpthread.so.0);
+ BEFORE_ORIGINAL_THREAD(pthread_attr_getdetachstate, LIBPTHREAD);
ret = pthread_attr_getdetachstatep(attr, detachstate);
static int (*pthread_attr_setdetachstatep)(pthread_attr_t *attr,
int detachstate);
- BEFORE_ORIGINAL_THREAD(pthread_attr_setdetachstate, libpthread.so.0);
+ BEFORE_ORIGINAL_THREAD(pthread_attr_setdetachstate, LIBPTHREAD);
ret = pthread_attr_setdetachstatep(attr, detachstate);
static int (*pthread_attr_getstacksizep)(const pthread_attr_t *attr,
size_t *stacksize);
- BEFORE_ORIGINAL_THREAD(pthread_attr_getstacksize, libpthread.so.0);
+ BEFORE_ORIGINAL_THREAD(pthread_attr_getstacksize, LIBPTHREAD);
ret = pthread_attr_getstacksizep(attr, stacksize);
static int (*pthread_attr_setstacksizep)(pthread_attr_t *attr,
size_t stacksize);
- BEFORE_ORIGINAL_THREAD(pthread_attr_setstacksize, libpthread.so.0);
+ BEFORE_ORIGINAL_THREAD(pthread_attr_setstacksize, LIBPTHREAD);
ret = pthread_attr_setstacksizep(attr, stacksize);
static int (*pthread_attr_getstackaddrp)(const pthread_attr_t *attr,
void **stackaddr);
- BEFORE_ORIGINAL_THREAD(pthread_attr_getstackaddr, libpthread.so.0);
+ BEFORE_ORIGINAL_THREAD(pthread_attr_getstackaddr, LIBPTHREAD);
ret = pthread_attr_getstackaddrp(attr, stackaddr);
static int (*pthread_attr_setstackaddrp)(pthread_attr_t *attr,
void *stackaddr);
- BEFORE_ORIGINAL_THREAD(pthread_attr_setstackaddr, libpthread.so.0);
+ BEFORE_ORIGINAL_THREAD(pthread_attr_setstackaddr, LIBPTHREAD);
ret = pthread_attr_setstackaddrp(attr, stackaddr);
static int (*pthread_attr_getinheritschedp)(const pthread_attr_t *attr,
int *inheritsched);
- BEFORE_ORIGINAL_THREAD(pthread_attr_getinheritsched, libpthread.so.0);
+ BEFORE_ORIGINAL_THREAD(pthread_attr_getinheritsched, LIBPTHREAD);
ret = pthread_attr_getinheritschedp(attr, inheritsched);
static int (*pthread_attr_setinheritschedp)(pthread_attr_t *attr,
int inheritsched);
- BEFORE_ORIGINAL_THREAD(pthread_attr_setinheritsched, libpthread.so.0);
+ BEFORE_ORIGINAL_THREAD(pthread_attr_setinheritsched, LIBPTHREAD);
ret = pthread_attr_setinheritschedp(attr, inheritsched);
static int (*pthread_attr_getschedparamp)(const pthread_attr_t *attr,
struct sched_param *param);
- BEFORE_ORIGINAL_THREAD(pthread_attr_getschedparam, libpthread.so.0);
+ BEFORE_ORIGINAL_THREAD(pthread_attr_getschedparam, LIBPTHREAD);
ret = pthread_attr_getschedparamp(attr, param);
static int (*pthread_attr_setschedparamp)(pthread_attr_t *attr,
const struct sched_param *param);
- BEFORE_ORIGINAL_THREAD(pthread_attr_setschedparam, libpthread.so.0);
+ BEFORE_ORIGINAL_THREAD(pthread_attr_setschedparam, LIBPTHREAD);
ret = pthread_attr_setschedparamp(attr, param);
static int (*pthread_attr_getschedpolicyp)(const pthread_attr_t *attr,
int *policy);
- BEFORE_ORIGINAL_THREAD(pthread_attr_getschedpolicy, libpthread.so.0);
+ BEFORE_ORIGINAL_THREAD(pthread_attr_getschedpolicy, LIBPTHREAD);
ret = pthread_attr_getschedpolicyp(attr, policy);
static int (*pthread_attr_setschedpolicyp)(pthread_attr_t *attr,
int policy);
- BEFORE_ORIGINAL_THREAD(pthread_attr_setschedpolicy, libpthread.so.0);
+ BEFORE_ORIGINAL_THREAD(pthread_attr_setschedpolicy, LIBPTHREAD);
ret = pthread_attr_setschedpolicyp(attr, policy);
static int (*pthread_attr_getguardsizep)(const pthread_attr_t *attr,
size_t *guardsize);
- BEFORE_ORIGINAL_THREAD(pthread_attr_getguardsize, libpthread.so.0);
+ BEFORE_ORIGINAL_THREAD(pthread_attr_getguardsize, LIBPTHREAD);
ret = pthread_attr_getguardsizep(attr, guardsize);
static int (*pthread_attr_setguardsizep)(pthread_attr_t *attr,
size_t guardsize);
- BEFORE_ORIGINAL_THREAD(pthread_attr_setguardsize, libpthread.so.0);
+ BEFORE_ORIGINAL_THREAD(pthread_attr_setguardsize, LIBPTHREAD);
ret = pthread_attr_setguardsizep(attr, guardsize);
static int (*pthread_attr_getscopep)(const pthread_attr_t *attr,
int *contentionscope);
- BEFORE_ORIGINAL_THREAD(pthread_attr_getscope, libpthread.so.0);
+ BEFORE_ORIGINAL_THREAD(pthread_attr_getscope, LIBPTHREAD);
ret = pthread_attr_getscopep(attr, contentionscope);
static int (*pthread_attr_setscopep)(pthread_attr_t *attr,
int contentionscope);
- BEFORE_ORIGINAL_THREAD(pthread_attr_setscope, libpthread.so.0);
+ BEFORE_ORIGINAL_THREAD(pthread_attr_setscope, LIBPTHREAD);
ret = pthread_attr_setscopep(attr, contentionscope);
static int (*pthread_attr_getstackp)(const pthread_attr_t *attr,
void **stackaddr, size_t *stacksize);
- BEFORE_ORIGINAL_THREAD(pthread_attr_getstack, libpthread.so.0);
+ BEFORE_ORIGINAL_THREAD(pthread_attr_getstack, LIBPTHREAD);
ret = pthread_attr_getstackp(attr, stackaddr, stacksize);
static int (*pthread_attr_setstackp)(pthread_attr_t *attr,
void *stackaddr, size_t stacksize);
- BEFORE_ORIGINAL_THREAD(pthread_attr_setstack, libpthread.so.0);
+ BEFORE_ORIGINAL_THREAD(pthread_attr_setstack, LIBPTHREAD);
ret = pthread_attr_setstackp(attr, stackaddr, stacksize);
static int (*app_efl_mainp)(int* argc, char*** argv, app_event_callback_s* callback, void* user_data);
int ret;
- GET_REAL_FUNC(app_efl_main, libcapi-appfw-application.so.0);
+ GET_REAL_FUNC(app_efl_main, LIBCAPI_APPFW_APPLICATION);
gAppCallback.create = callback->create;
gAppCallback.terminate = callback->terminate;
static methodType _ecoreevasmgr_setecoreevasp;
GET_REAL_FUNC_OSP(_ZN5Tizen2Ui13_EcoreEvasMgr12SetEcoreEvasERKNS0_10_EcoreEvasE,
- libosp-uifw.so, _ecoreevasmgr_setecoreevasp);
+ LIBOSP_UIFW, _ecoreevasmgr_setecoreevasp);
probeBlockStart();
evas_event_callback_add(ecoreevas.GetEvas(),
result ret;
GET_REAL_FUNC_OSP(_ZN5Tizen2Ui7Control12SetShowStateEb,
- libosp-uifw.so, control_setshowstatep);
+ LIBOSP_UIFW, control_setshowstatep);
ret = (this->*control_setshowstatep)(state);
result ret;
GET_REAL_FUNC_OSP(_ZN5Tizen2Ui8Controls5Frame14SetCurrentFormERKNS1_4FormE,
- libosp-uifw.so, frame_setcurrentformp);
+ LIBOSP_UIFW, frame_setcurrentformp);
ret = (this->*frame_setcurrentformp)(form);
result ret;
GET_REAL_FUNC_OSP(_ZN5Tizen2Ui10Animations13FrameAnimator14SetCurrentFormERKNS0_8Controls4FormE,
- libosp-uifw.so, frameanimator_setcurrentformp);
+ LIBOSP_UIFW, frameanimator_setcurrentformp);
ret = (this->*frameanimator_setcurrentformp)(form);
static methodtype mp;
bool ret;
- GET_REAL_FUNC_OSP(_ZN5Tizen2Ui10Animations15_DisplayManager9RenderAllEb, libosp-uifw.so, mp);
+ GET_REAL_FUNC_OSP(_ZN5Tizen2Ui10Animations15_DisplayManager9RenderAllEb, LIBOSP_UIFW, mp);
probeBlockStart();
probeBlockEnd();
static methodtype mp;
bool ret;
- GET_REAL_FUNC_OSP(_ZN5Tizen2Ui10Animations15_DisplayManager6RenderERNS1_18_RootVisualElementEb, libosp-uifw.so, mp);
+ GET_REAL_FUNC_OSP(_ZN5Tizen2Ui10Animations15_DisplayManager6RenderERNS1_18_RootVisualElementEb, LIBOSP_UIFW, mp);
probeBlockStart();
probeBlockEnd();
ret = (this->*mp)(root, check);
static methodtype mp;
result ret;
- GET_REAL_FUNC_OSP(_ZN5Tizen2Ui10Animations15_DisplayManager10PostRenderERNS1_18_RootVisualElementE, libosp-uifw.so, mp);
+ GET_REAL_FUNC_OSP(_ZN5Tizen2Ui10Animations15_DisplayManager10PostRenderERNS1_18_RootVisualElementE, LIBOSP_UIFW, mp);
probeBlockStart();
probeBlockEnd();
static methodtype mp;
result ret;
- GET_REAL_FUNC_OSP(_ZN5Tizen2Ui10Animations15_DisplayManager5FlushEv, libosp-uifw.so, mp);
+ GET_REAL_FUNC_OSP(_ZN5Tizen2Ui10Animations15_DisplayManager5FlushEv, LIBOSP_UIFW, mp);
probeBlockStart();
probeBlockEnd();
ret = (this->*mp)();
static methodtype mp;
bool ret;
- GET_REAL_FUNC_OSP(_ZN5Tizen2Ui10Animations15_DisplayManager11UpdateSceneEb, libosp-uifw.so, mp);
+ GET_REAL_FUNC_OSP(_ZN5Tizen2Ui10Animations15_DisplayManager11UpdateSceneEb, LIBOSP_UIFW, mp);
probeBlockStart();
probeBlockEnd();
ret = (this->*mp)(force);
static int initialized = 0;
SceneManager* ret;
- GET_REAL_FUNC_OSP(_ZN5Tizen2Ui6Scenes12SceneManager11GetInstanceEv, libosp-uifw.so, scenemanager_getinstancep);
+ GET_REAL_FUNC_OSP(_ZN5Tizen2Ui6Scenes12SceneManager11GetInstanceEv, LIBOSP_UIFW, scenemanager_getinstancep);
ret = scenemanager_getinstancep();
{
static Evas_Object * (*elm_win_addp)(Evas_Object *parent, const char* name, Elm_Win_Type type);
- BEFORE_ORIGINAL_SNAPSHOT(elm_win_add, libelementary.so);
+ BEFORE_ORIGINAL_SNAPSHOT(elm_win_add, LIBELEMENTARY);
ret = elm_win_addp(parent, name, type);
{
static Evas_Object * (*elm_controlbar_addp)(Evas_Object *parent);
- BEFORE_ORIGINAL_SNAPSHOT(elm_controlbar_add, libelementary.so);
+ BEFORE_ORIGINAL_SNAPSHOT(elm_controlbar_add, LIBELEMENTARY);
ret = elm_controlbar_addp(parent);
{
static Evas_Object * (*elm_naviframe_addp)(Evas_Object *parent);
- BEFORE_ORIGINAL_SNAPSHOT(elm_naviframe_add, libelementary.so);
+ BEFORE_ORIGINAL_SNAPSHOT(elm_naviframe_add, LIBELEMENTARY);
ret = elm_naviframe_addp(parent);
{
static Evas_Object * (*elm_pager_addp)(Evas_Object *parent);
- BEFORE_ORIGINAL_SNAPSHOT(elm_pager_add, libelementary.so);
+ BEFORE_ORIGINAL_SNAPSHOT(elm_pager_add, LIBELEMENTARY);
ret = elm_pager_addp(parent);
projects / framework / system / dynamic-analysis-probe.git / commitdiff