Resolve shared libraries in an architecture independent way

Instead of relying on the hosts ldd, implement a pure golang resolver
for shared libraries which can also be used for cross-compilation.

Signed-off-by: Roman Mohr <[email protected]>

Author: rmohr

cmd/BUILD.bazel

@@ -23,6 +23,7 @@ go_library(
         "//pkg/api",
         "//pkg/api/bazeldnf",
         "//pkg/bazel",
+        "//pkg/ldd",
         "//pkg/order",
         "//pkg/reducer",
         "//pkg/repo",
@@ -31,7 +32,6 @@ go_library(
         "@com_github_sassoftware_go_rpmutils//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
         "@com_github_spf13_cobra//:go_default_library",
-        "@com_github_u_root_u_root//pkg/ldd:go_default_library",
         "@org_golang_x_crypto//openpgp:go_default_library",
     ],
 )

cmd/ldd.go

@@ -8,10 +8,10 @@ import (
 	"strings"
 
 	"github.com/rmohr/bazeldnf/pkg/bazel"
+	"github.com/rmohr/bazeldnf/pkg/ldd"
 	"github.com/rmohr/bazeldnf/pkg/rpm"
 	"github.com/sirupsen/logrus"
 	"github.com/spf13/cobra"
-	"github.com/u-root/u-root/pkg/ldd"
 )
 
 type lddOpts struct {
@@ -46,19 +46,18 @@ func NewlddCmd() *cobra.Command {
 				objects[i] = filepath.Join(tmpRoot, objects[i])
 			}
 
-			err = os.Setenv("LD_LIBRARY_PATH", filepath.Join(tmpRoot, "/usr/lib64"))
-			if err != nil {
-				return err
-			}
-
 			files := []string{}
-			dependencies, err := ldd.Ldd(objects)
+			dependencies, err := ldd.Resolve(objects, filepath.Join(tmpRoot, "/usr/lib64"))
 			if err != nil {
 				return err
 			}
 			for _, dep := range dependencies {
-				if strings.HasPrefix(dep.FullName, tmpRoot) {
-					files = append(files, strings.TrimPrefix(dep.FullName, tmpRoot))
+				if strings.HasPrefix(dep, tmpRoot) {
+					if strings.HasPrefix(filepath.Base(dep), "ld-") {
+						// don't link against ld itself
+						continue
+					}
+					files = append(files, strings.TrimPrefix(dep, tmpRoot))
 				}
 			}
 			err = filepath.Walk(filepath.Join(tmpRoot, "/usr/include"),

deps.bzl

@@ -589,14 +589,6 @@ def bazeldnf_dependencies():
         sum = "h1:LnC5Kc/wtumK+WB441p7ynQJzVuNRJiqddSIE3IlSEQ=",
         version = "v0.0.0-20190109142713-0ad062ec5ee5",
     )
-    _maybe(
-        _go_repository,
-        name = "com_github_u_root_u_root",
-        importpath = "github.com/u-root/u-root",
-        sum = "h1:u+KSS04pSxJGI5E7WE4Bs9+Zd75QjFv+REkjy/aoAc8=",
-        version = "v7.0.0+incompatible",
-    )
-
     _maybe(
         _go_repository,
         name = "com_github_ugorji_go",

go.mod

@@ -9,7 +9,6 @@ require (
 	github.com/sassoftware/go-rpmutils v0.1.1
 	github.com/sirupsen/logrus v1.6.0
 	github.com/spf13/cobra v1.0.0
-	github.com/u-root/u-root v7.0.0+incompatible
 	sigs.k8s.io/yaml v1.2.0
 )
 

pkg/ldd/BUILD.bazel

@@ -0,0 +1,8 @@
+load("@io_bazel_rules_go//go:def.bzl", "go_library")
+
+go_library(
+    name = "ldd",
+    srcs = ["ldd.go"],
+    importpath = "github.com/rmohr/bazeldnf/pkg/ldd",
+    visibility = ["//visibility:public"],
+)

pkg/ldd/ldd.go

@@ -0,0 +1,110 @@
+package ldd
+
+import (
+	"debug/elf"
+	"os"
+	"path/filepath"
+)
+
+func Resolve(objects []string, library_path string) (finalFiles []string, err error) {
+	discovered := map[string]struct{}{}
+	for _, obj := range objects {
+		if files, err := resolve(obj, library_path); err != nil {
+			return nil, err
+		} else {
+			for _, l := range files {
+				if _, exists := discovered[l]; !exists {
+					discovered[l] = struct{}{}
+					finalFiles = append(finalFiles, l)
+				}
+			}
+		}
+	}
+	return
+}
+
+func resolve(library string, library_path string) ([]string, error) {
+
+	next := []string{library}
+	processed := map[string]struct{}{}
+
+	finalFiles := []string{}
+	for {
+		if len(next) == 0 {
+			break
+		}
+		if d, err := ldd(next[0], library_path); err != nil {
+			return nil, err
+		} else {
+			for _, l := range d {
+				if _, exists := processed[l]; !exists {
+					next = append(next, l)
+					processed[l] = struct{}{}
+					finalFiles = append(finalFiles, l)
+				}
+			}
+			if len(next) > 1 {
+				next = next[1 : len(next)-1]
+			} else {
+				next = []string{}
+			}
+		}
+	}
+
+	finalFiles = append(finalFiles, library)
+	symlinks, err := followSymlinks(library)
+	if err != nil {
+		return nil, err
+	}
+	finalFiles = append(finalFiles, symlinks...)
+
+	return finalFiles, nil
+}
+
+func ldd(library string, library_path string) (discovered []string, err error) {
+	bin, err := elf.Open(library)
+	if err != nil {
+		return nil, err
+	}
+	libs, err := bin.ImportedLibraries()
+	if err != nil {
+		return nil, err
+	}
+	for _, l := range libs {
+		_, err := os.Stat(filepath.Join(library_path, l))
+		if err != nil {
+			return nil, err
+		}
+		discovered = append(discovered, filepath.Join(library_path, l))
+		symlinks, err := followSymlinks(filepath.Join(library_path, l))
+		if err != nil {
+			return nil, err
+		}
+		discovered = append(discovered, symlinks...)
+	}
+	return discovered, nil
+}
+
+func followSymlinks(file string) (files []string, err error) {
+	dir := filepath.Dir(file)
+	for {
+		info, err := os.Lstat(file)
+		if err != nil {
+			return nil, err
+		}
+		if info.Mode()&os.ModeSymlink == os.ModeSymlink {
+			file, err = os.Readlink(file)
+			if err != nil {
+				return nil, err
+			}
+			if !filepath.IsAbs(file) {
+				file = filepath.Join(dir, file)
+			}
+			files = append(files, file)
+		} else {
+			files = append(files, file)
+			break
+		}
+	}
+	return
+}