2 files changed, 132 insertions, 0 deletions
diff --git a/dl/dl_gnu.go b/dl/dl_gnu.go
new file mode 100644
index 0000000..c7c409b
--- /dev/null
+++ b/dl/dl_gnu.go
@@ -0,0 +1,58 @@
+package dl
+
+import "unsafe"
+
+//#define _GNU_SOURCE
+//#include <stdlib.h>
+//#include <stdint.h>
+//#include <dlfcn.h>
+//const uintptr_t rtld_next = (uintptr_t)RTLD_NEXT;
+//const uintptr_t rtld_default = (uintptr_t)RTLD_DEFAULT;
+import "C"
+
+const (
+	RTLD_NOLOAD   Flag = C.RTLD_NOLOAD
+	RTLD_NODELETE Flag = C.RTLD_NODELETE
+	RTLD_DEEPBIND Flag = C.RTLD_DEEPBIND
+)
+
+// These are kinda weird in that they aren't required by the standard,
+// but they are reserved by the standard (see the documentation for
+// `dlsym(3)`).  On glibc, it takes _GNU_SOURCE to get them.
+//
+//        There are two special pseudo-handles that may be specified
+//        in handle:
+var (
+	RTLD_DEFAULT Handle = Handle{unsafe.Pointer(uintptr(C.rtld_default))}
+           // Find the first occurrence of the desired symbol using
+           // the default shared object search order.  The search will
+           // include global symbols in the executable and its
+           // dependencies, as well as symbols in shared objects that
+           // were dynamically loaded with the RTLD_GLOBAL flag.
+	RTLD_NEXT    Handle = Handle{unsafe.Pointer(uintptr(C.rtld_next))}
+           // Find the next occurrence of the desired symbol in the
+           // search order after the current object.  This allows one
+           // to provide a wrapper around a function in another shared
+           // object, so that, for example, the definition of a
+           // function in a preloaded shared object (see LD_PRELOAD in
+           // ld.so(8)) can find and invoke the "real" function
+           // provided in another shared object (or for that matter,
+           // the "next" definition of the function in cases where
+           // there are multiple layers of preloading).
+)
+
+// TODO: dlmopen
+// TODO: dlvsym
+// TODO: dladdr
+//     - dladdr1
+// TODO: dlinfo
+//     - RTLD_DI_LMID
+//     - RTLD_DI_LINKMAP
+//     - RTLD_DI_ORIGIN
+//     - RTLD_DI_SERINFO
+//     - RTLD_DI_SERINFOSIZE
+//     - RTLD_DI_MODID
+//     - RTLD_DI_DATA
+// TODO: dl_iterate_phdr
+// TODO: rtld-audit(7)
+
diff --git a/dl/dlfcn.go b/dl/dlfcn.go
new file mode 100644
index 0000000..d5467f3
--- /dev/null
+++ b/dl/dlfcn.go
@@ -0,0 +1,74 @@
+package dl
+
+import (
+	"errors"
+	"unsafe"
+)
+
+//#cgo LDFLAGS: -ldl
+//#include <stdlib.h>
+//#include <dlfcn.h>
+import "C"
+
+type Flag int
+
+const (
+	RTLD_LAZY   Flag = C.RTLD_LAZY   // Relocations are performed at an
+					 // implementation-defined time.
+	RTLD_NOW    Flag = C.RTLD_NOW    // Relocations are performed when the
+				         // object is loaded.
+	RTLD_GLOBAL Flag = C.RTLD_GLOBAL // All symbols are available for
+					 // relocation processing of other
+					 // modules.
+	RTLD_LOCAL  Flag = C.RTLD_LOCAL  // All symbols are not made available
+					 // for relocation processing by other
+					 // modules.
+)
+
+type Handle struct {
+	c unsafe.Pointer
+}
+
+func Open(name string, flags Flag) (Handle, error) {
+	nameC := C.CString(name)
+	defer C.free(unsafe.Pointer(nameC))
+
+	dlerror()
+	ptr := C.dlopen(nameC, C.int(flags))
+	if ptr == nil {
+		return Handle{}, dlerror()
+	}
+	return Handle{ptr}, nil
+}
+
+// This returns uintptr instead of unsafe.Pointer so that code using
+// reflect cannot obtain unsafe.Pointers without importing the unsafe
+// package explicitly.
+func (h Handle) Sym(symbol string) (uintptr, error) {
+	symbolC := C.CString(symbol)
+	defer C.free(unsafe.Pointer(symbolC))
+
+	dlerror()
+	ptr := C.dlsym(h.c, symbolC)
+	if ptr == nil {
+		return 0, dlerror()
+	}
+	return uintptr(ptr), nil
+}
+
+func (h Handle) Close() error {
+	dlerror()
+	r := C.dlclose(h.c)
+	if r != 0 {
+		return dlerror()
+	}
+	return nil
+}
+
+func dlerror() error {
+	strC := C.dlerror()
+	if strC == nil {
+		return nil
+	}
+	return errors.New(C.GoString(strC))
+}