Fix drive handle leak, silent ParseInt errors, dead code, and duplication (#11)

- Extract unlock() and Execute() to internal/pba to eliminate verbatim
  duplication across both pbainit commands
- Fix defer d.Close() inside device loop (defers are function-scoped;
  all handles leaked until main() returned)
- Fix strconv.ParseInt bitsize int8→int32 and add error handling; int8
  is too small for Linux device major numbers and a malformed sysfs
  entry could panic on parts[1] index or silently write a wrong Mknod
- Remove always-false reboot_bug variable and its dead branch (all
  assignments were commented out); rename pci_block→pciBlock
- Replace deprecated ioutil.ReadDir/ReadFile with os.ReadDir/ReadFile

Co-authored-by: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: wicked-wix

cmd/pbainit-interactive/main.go

@@ -1,13 +1,10 @@
 package main
 
 import (
-	"crypto/sha1"
 	"encoding/base64"
 	"fmt"
-	"io/ioutil"
 	"log"
 	"os"
-	"os/exec"
 	"path/filepath"
 	"strconv"
 	"strings"
@@ -16,13 +13,13 @@ import (
 
 	tcg "github.com/open-source-firmware/go-tcg-storage/pkg/core"
 	"github.com/open-source-firmware/go-tcg-storage/pkg/drive"
-	"github.com/open-source-firmware/go-tcg-storage/pkg/locking"
 	"github.com/u-root/u-root/pkg/libinit"
 	"github.com/u-root/u-root/pkg/mount"
 	"github.com/u-root/u-root/pkg/ulog"
-	"golang.org/x/crypto/pbkdf2"
 	"golang.org/x/sys/unix"
 	"golang.org/x/term"
+
+	"github.com/elastx/elx-pba/internal/pba"
 )
 
 var (
@@ -60,11 +57,11 @@ func main() {
 	defer func() {
 		log.Printf("Starting emergency shell...")
 		for {
-			Execute("/bbin/elvish")
+			pba.Execute("/bbin/elvish")
 		}
 	}()
 
-	sysblk, err := ioutil.ReadDir("/sys/class/block/")
+	sysblk, err := os.ReadDir("/sys/class/block/")
 	if err != nil {
 		log.Printf("Failed to enumerate block devices: %v", err)
 		return
@@ -79,14 +76,22 @@ func main() {
 		}
 		devpath := filepath.Join("/dev", devname)
 		if _, err := os.Stat(devpath); os.IsNotExist(err) {
-			majmin, err := ioutil.ReadFile(filepath.Join("/sys/class/block", devname, "dev"))
+			majmin, err := os.ReadFile(filepath.Join("/sys/class/block", devname, "dev"))
 			if err != nil {
 				log.Printf("Failed to read major:minor for %s: %v", devname, err)
 				continue
 			}
 			parts := strings.Split(strings.TrimSpace(string(majmin)), ":")
-			major, _ := strconv.ParseInt(parts[0], 10, 8)
-			minor, _ := strconv.ParseInt(parts[1], 10, 8)
+			if len(parts) != 2 {
+				log.Printf("Unexpected major:minor format for %s: %q", devname, string(majmin))
+				continue
+			}
+			major, errMaj := strconv.ParseInt(parts[0], 10, 32)
+			minor, errMin := strconv.ParseInt(parts[1], 10, 32)
+			if errMaj != nil || errMin != nil {
+				log.Printf("Failed to parse major:minor for %s: %v %v", devname, errMaj, errMin)
+				continue
+			}
 			if err := unix.Mknod(filepath.Join("/dev", devname), unix.S_IFBLK|0600, int(major<<16|minor)); err != nil {
 				log.Printf("Mknod(%s) failed: %v", devname, err)
 				continue
@@ -98,7 +103,6 @@ func main() {
 			log.Printf("drive.Open(%s): %v", devpath, err)
 			continue
 		}
-		defer d.Close()
 		identity, err := d.Identify()
 		if err != nil {
 			log.Printf("drive.Identify(%s): %v", devpath, err)
@@ -109,6 +113,7 @@ func main() {
 		}
 		d0, err := tcg.Discovery0(d)
 		if err != nil {
+			d.Close()
 			if err != tcg.ErrNotSupported {
 				log.Printf("tcg.Discovery0(%s): %v", devpath, err)
 			}
@@ -121,17 +126,14 @@ func main() {
 			}
 			unlocked := false
 			for !unlocked {
-				// reuse-existing password for multiple drives
 				if password == "" {
 					password = getDrivePassword()
 					if password == "" {
-						// skip on empty password
 						break
 					}
 				}
-				if err := unlock(d, password, dsn); err != nil {
+				if err := pba.Unlock(d, password, dsn); err != nil {
 					log.Printf("Failed to unlock %s: %v", identity, err)
-					// clear password to be queried again
 					password = ""
 				} else {
 					unlocked = true
@@ -144,6 +146,7 @@ func main() {
 		} else {
 			log.Printf("Considered drive %s, but drive is not locked", identity)
 		}
+		d.Close()
 	}
 
 	if startEmergencyShell {
@@ -156,13 +159,12 @@ func main() {
 		return
 	}
 
-	// reboot for now as 'boot' would mount filesystems and therefore mess up hibernation :-(
-	// note that ext3 or ext4 will replay its journal even when mounted read-only if the filesystem is dirty
-	Execute("/bbin/shutdown", "reboot")
+	// reboot rather than kexec: 'boot' mounts filesystems which breaks hibernation,
+	// and ext3/ext4 replays its journal even on read-only mounts when the fs is dirty
+	pba.Execute("/bbin/shutdown", "reboot")
 }
 
 func getDrivePassword() string {
-	// avoid kernel log messages messing up prompt
 	if err := ulog.KernelLog.SetConsoleLogLevel(ulog.KLogWarning); err != nil {
 		log.Printf("Could not set log level KLogWarning: %v", err)
 	}
@@ -178,41 +180,7 @@ func getDrivePassword() string {
 	return string(bytePassword)
 }
 
-func unlock(d tcg.DriveIntf, pass string, driveserial []byte) error {
-	// Same format as used by sedutil for compatibility
-	salt := fmt.Sprintf("%-20s", string(driveserial))
-	pin := pbkdf2.Key([]byte(pass), []byte(salt[:20]), 75000, 32, sha1.New)
-
-	cs, lmeta, err := locking.Initialize(d)
-	if err != nil {
-		return fmt.Errorf("locking.Initialize: %v", err)
-	}
-	defer cs.Close()
-	l, err := locking.NewSession(cs, lmeta, locking.DefaultAuthority(pin))
-	if err != nil {
-		return fmt.Errorf("locking.NewSession: %v", err)
-	}
-	defer l.Close()
-
-	for i, r := range l.Ranges {
-		if err := r.UnlockRead(); err != nil {
-			log.Printf("Read unlock range %d failed: %v", i, err)
-		}
-		if err := r.UnlockWrite(); err != nil {
-			log.Printf("Write unlock range %d failed: %v", i, err)
-		}
-	}
-
-	if l.MBREnabled && !l.MBRDone {
-		if err := l.SetMBRDone(true); err != nil {
-			return fmt.Errorf("SetMBRDone: %v", err)
-		}
-	}
-	return nil
-}
-
 func waitForEnter(prompt string, seconds int) bool {
-
 	f, err := os.OpenFile("/dev/console", os.O_RDWR, 0)
 	if err != nil {
 		log.Printf("ERROR: Open /dev/console failed: %v", err)
@@ -247,28 +215,6 @@ func waitForEnter(prompt string, seconds int) bool {
 		}
 	}
 
-	// nobody pressed enter (need \r to reset start of line)
 	fmt.Println("\r")
 	return false
 }
-
-func Execute(name string, args ...string) {
-	environ := append(os.Environ(), "USER=root")
-	environ = append(environ, "HOME=/root")
-	environ = append(environ, "TZ=UTC")
-
-	cmd := exec.Command(name, args...)
-	cmd.Dir = "/"
-	cmd.Env = environ
-	cmd.Stdin = os.Stdin
-	cmd.Stderr = os.Stderr
-	cmd.Stdout = os.Stdout
-	if cmd.SysProcAttr == nil {
-		cmd.SysProcAttr = &syscall.SysProcAttr{}
-	}
-	cmd.SysProcAttr.Setctty = true
-	cmd.SysProcAttr.Setsid = true
-	if err := cmd.Run(); err != nil {
-		log.Printf("Failed to execute: %v", err)
-	}
-}