DAOS-13194 gurt: environment APIs hook

src/gurt/SConscript

@@ -19,7 +19,7 @@ def scons():
 
     denv = env.Clone()
 
-    denv.AppendUnique(LIBS=['pthread', 'yaml', 'm'])
+    denv.AppendUnique(LIBS=['pthread', 'yaml', 'm', 'dl'])
     denv.require('uuid')
 
     gurt_targets = denv.SharedObject(SRC)

src/gurt/misc.c

@@ -12,6 +12,11 @@
 #include <stdarg.h>
 #include <math.h>
 #include <string.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <dlfcn.h>
+#include <pthread.h>
+
 #include <gurt/common.h>
 
 /* state buffer for DAOS rand and srand calls, NOT thread safe */
@@ -1192,3 +1197,145 @@ d_vec_pointers_append(struct d_vec_pointers *pointers, void *pointer)
 	pointers->p_len++;
 	return 0;
 }
+
+/**
+ * Overloads to hook the unsafe getenv()/[un]setenv()/putenv()/clearenv()
+ * functions from glibc.
+ * Libgurt is the preferred place for this as it is the lowest layer in DAOS,
+ * so it will be the earliest to be loaded and will ensure the hook to be
+ * installed as early as possible and could prevent usage of LD_PRELOAD.
+ * The idea is to strengthen all the environment APIs by using a common lock.
+ *
+ * XXX this will address the main lack of multi-thread protection in the Glibc
+ * APIs but do not handle all unsafe use-cases (like the change/removal of an
+ * env var when its value address has already been grabbed by a previous
+ * getenv(), ...).
+ */
+
+static pthread_mutex_t hook_env_lock = PTHREAD_MUTEX_INITIALIZER;
+static char *(*real_getenv)(const char *);
+static int (*real_putenv)(char *);
+static int (*real_setenv)(const char *, const char *, int);
+static int (*real_unsetenv)(const char *);
+static int (*real_clearenv)(void);
+
+char *getenv(const char *name)
+{
+	char *p;
+
+	D_MUTEX_LOCK(&hook_env_lock);
+	if (real_getenv == NULL) {
+		real_getenv = (char * (*)(const char *))dlsym(RTLD_NEXT, "getenv");
+		if (real_getenv == NULL) {
+			/* Glibc symbols could not be resolved !!... */
+			void *handle;
+
+			handle = dlopen("libc.so.6", RTLD_LAZY);
+			D_ASSERT(handle != NULL);
+			real_getenv = (char * (*)(const char *))dlsym(handle, "getenv");
+		}
+		D_ASSERT(real_getenv != NULL);
+	}
+
+	p = real_getenv(name);
+	D_MUTEX_UNLOCK(&hook_env_lock);
+
+	return p;
+}
+
+int putenv(char *name)
+{
+	int rc;
+
+	D_MUTEX_LOCK(&hook_env_lock);
+	if (real_putenv == NULL) {
+		real_putenv = (int (*)(char *))dlsym(RTLD_NEXT, "putenv");
+		if (real_putenv == NULL) {
+			/* Glibc symbols could not be resolved !!... */
+			void *handle;
+
+			handle = dlopen("libc.so.6", RTLD_LAZY);
+			D_ASSERT(handle != NULL);
+			real_putenv = (int (*)(char *))dlsym(handle, "putenv");
+		}
+		D_ASSERT(real_putenv != NULL);
+	}
+
+	rc = real_putenv(name);
+	D_MUTEX_UNLOCK(&hook_env_lock);
+
+	return rc;
+}
+
+int setenv(const char *name, const char *value, int overwrite)
+{
+	int rc;
+
+	D_MUTEX_LOCK(&hook_env_lock);
+	if (real_setenv == NULL) {
+		real_setenv = (int (*)(const char *, const char *, int))dlsym(RTLD_NEXT, "setenv");
+		if (real_setenv == NULL) {
+			/* Glibc symbols could not be resolved !!... */
+			void *handle;
+
+			handle = dlopen("libc.so.6", RTLD_LAZY);
+			D_ASSERT(handle != NULL);
+			real_setenv = (int (*)(const char *, const char *, int))dlsym(handle,
+				      "setenv");
+		}
+		D_ASSERT(real_setenv != NULL);
+	}
+
+	rc = real_setenv(name, value, overwrite);
+	D_MUTEX_UNLOCK(&hook_env_lock);
+
+	return rc;
+}
+
+int unsetenv(const char *name)
+{
+	int rc;
+
+	D_MUTEX_LOCK(&hook_env_lock);
+	if (real_unsetenv == NULL) {
+		real_unsetenv = (int (*)(const char *))dlsym(RTLD_NEXT, "unsetenv");
+		if (real_unsetenv == NULL) {
+			/* Glibc symbols could not be resolved !!... */
+			void *handle;
+
+			handle = dlopen("libc.so.6", RTLD_LAZY);
+			D_ASSERT(handle != NULL);
+			real_unsetenv = (int (*)(const char *))dlsym(handle, "unsetenv");
+		}
+		D_ASSERT(real_unsetenv != NULL);
+	}
+
+	rc = real_unsetenv(name);
+	D_MUTEX_UNLOCK(&hook_env_lock);
+
+	return rc;
+}
+
+int clearenv(void)
+{
+	int rc;
+
+	D_MUTEX_LOCK(&hook_env_lock);
+	if (real_clearenv == NULL) {
+		real_clearenv = (int (*)(void))dlsym(RTLD_NEXT, "clearenv");
+		if (real_clearenv == NULL) {
+			/* Glibc symbols could not be resolved !!... */
+			void *handle;
+
+			handle = dlopen("libc.so.6", RTLD_LAZY);
+			D_ASSERT(handle != NULL);
+			real_clearenv = (int (*)(void))dlsym(handle, "clearenv");
+		}
+		D_ASSERT(real_clearenv != NULL);
+	}
+
+	rc = real_clearenv();
+	D_MUTEX_UNLOCK(&hook_env_lock);
+
+	return rc;
+}

src/gurt/tests/SConscript

@@ -18,7 +18,7 @@ def scons():
 
     test_env = env.Clone()
     test_env.require('mercury', 'uuid')
-    test_env.AppendUnique(LIBS=['pthread', 'cmocka', 'm'])
+    test_env.AppendUnique(LIBS=['pthread', 'cmocka', 'm', 'dl'])
     test_env.AppendUnique(CXXFLAGS=['-std=c++0x'])
     tests = []
 

src/tests/ftest/cart/utest/SConscript

@@ -19,7 +19,7 @@ def scons():
 
     test_env = env.Clone()
     test_env.require('mercury', 'uuid', 'cmocka')
-    test_env.AppendUnique(LIBS=['pthread', 'm'])
+    test_env.AppendUnique(LIBS=['pthread', 'm', 'dl'])
     test_env.AppendUnique(CXXFLAGS=['-std=c++0x'])
     test_env.AppendUnique(LIBPATH=LIBPATH)
     test_env.AppendUnique(RPATH_FULL=LIBPATH)