Merge pull request #475 from kolyshkin/error

Misc error reporting improvements

Author: Luap99

daemon/watchdog.go

@@ -15,6 +15,7 @@
 package daemon
 
 import (
+	"errors"
 	"fmt"
 	"os"
 	"strconv"
@@ -51,10 +52,10 @@ func SdWatchdogEnabled(unsetEnvironment bool) (time.Duration, error) {
 	}
 	s, err := strconv.Atoi(wusec)
 	if err != nil {
-		return 0, fmt.Errorf("error converting WATCHDOG_USEC: %s", err)
+		return 0, fmt.Errorf("error converting WATCHDOG_USEC: %w", err)
 	}
 	if s <= 0 {
-		return 0, fmt.Errorf("error WATCHDOG_USEC must be a positive number")
+		return 0, errors.New("error WATCHDOG_USEC must be a positive number")
 	}
 	interval := time.Duration(s) * time.Microsecond
 
@@ -63,7 +64,7 @@ func SdWatchdogEnabled(unsetEnvironment bool) (time.Duration, error) {
 	}
 	p, err := strconv.Atoi(wpid)
 	if err != nil {
-		return 0, fmt.Errorf("error converting WATCHDOG_PID: %s", err)
+		return 0, fmt.Errorf("error converting WATCHDOG_PID: %w", err)
 	}
 	if os.Getpid() != p {
 		return 0, nil

import1/dbus.go

@@ -177,9 +177,9 @@ func (c *Conn) ListTransfers() ([]TransferStatus, error) {
 
 	transfers := make([]TransferStatus, 0)
 	for _, v := range result {
-		transfer, err := transferFromInterfaces(v)
-		if err != nil {
-			return nil, err
+		transfer := transferFromInterfaces(v)
+		if transfer == nil {
+			return nil, fmt.Errorf("ListTransfers: can't parse response %+v", v)
 		}
 		transfers = append(transfers, *transfer)
 	}
@@ -192,48 +192,48 @@ func (c *Conn) CancelTransfer(transfer_id uint32) error {
 	return c.object.Call(dbusInterface+".CancelTransfer", 0, transfer_id).Err
 }
 
-func transferFromInterfaces(transfer []any) (*TransferStatus, error) {
+func transferFromInterfaces(transfer []any) *TransferStatus {
 	// Verify may be not defined in response.
 	if len(transfer) < 5 {
-		return nil, fmt.Errorf("invalid number of transfer fields: %d", len(transfer))
+		return nil
 	}
 
 	ok := false
 	ret := &TransferStatus{}
 
 	ret.Id, ok = transfer[0].(uint32)
 	if !ok {
-		return nil, fmt.Errorf("failed to typecast transfer field 0 to uint32")
+		return nil
 	}
 	ret.Local, ok = transfer[1].(string)
 	if !ok {
-		return nil, fmt.Errorf("failed to typecast transfer field 1 to string")
+		return nil
 	}
 	ret.Remote, ok = transfer[2].(string)
 	if !ok {
-		return nil, fmt.Errorf("failed to typecast transfer field 2 to string")
+		return nil
 	}
 	ret.Type, ok = transfer[3].(string)
 	if !ok {
-		return nil, fmt.Errorf("failed to typecast transfer field 3 to string")
+		return nil
 	}
 	// Verify is only defined for download operations.
 	// If operation is not pull, we should ignore Verify field.
 	if !strings.HasPrefix(ret.Type, "pull-") {
 		ret.Progress, ok = transfer[4].(float64)
 		if !ok {
-			return nil, fmt.Errorf("failed to typecast transfer field 4 to float64")
+			return nil
 		}
-		return ret, nil
+		return ret
 	}
 
 	ret.Verify, ok = transfer[4].(string)
 	if !ok {
-		return nil, fmt.Errorf("failed to typecast transfer field 4 to string")
+		return nil
 	}
 	ret.Progress, ok = transfer[5].(float64)
 	if !ok {
-		return nil, fmt.Errorf("failed to typecast transfer field 5 to float64")
+		return nil
 	}
-	return ret, nil
+	return ret
 }

internal/dlopen/dlopen.go

@@ -69,7 +69,7 @@ func (l *LibHandle) GetSymbolPointer(symbol string) (unsafe.Pointer, error) {
 	p := C.dlsym(l.Handle, sym)
 	e := C.dlerror()
 	if e != nil {
-		return nil, fmt.Errorf("error resolving symbol %q: %v", symbol, errors.New(C.GoString(e)))
+		return nil, fmt.Errorf("error resolving symbol %q: %s", symbol, C.GoString(e))
 	}
 
 	return p, nil
@@ -85,7 +85,7 @@ func (l *LibHandle) Close() error {
 	C.dlclose(l.Handle)
 	e := C.dlerror()
 	if e != nil {
-		return fmt.Errorf("error closing %v: %v", l.Libname, errors.New(C.GoString(e)))
+		return fmt.Errorf("error closing %v: %s", l.Libname, C.GoString(e))
 	}
 
 	return nil

internal/dlopen/dlopen_example.go

@@ -30,14 +30,13 @@ package dlopen
 import "C"
 
 import (
-	"fmt"
 	"unsafe"
 )
 
 func strlen(libs []string, s string) (int, error) {
 	h, err := GetHandle(libs)
 	if err != nil {
-		return -1, fmt.Errorf(`couldn't get a handle to the library: %v`, err)
+		return -1, err
 	}
 	defer h.Close()
 
@@ -47,7 +46,7 @@ func strlen(libs []string, s string) (int, error) {
 
 	strlen, err := h.GetSymbolPointer(f)
 	if err != nil {
-		return -1, fmt.Errorf(`couldn't get symbol %q: %v`, f, err)
+		return -1, err
 	}
 
 	len := C.my_strlen(strlen, cs)

journal/journal_unix.go

@@ -106,7 +106,7 @@ func fdIsJournalStream(fd int) (bool, error) {
 	var expectedStat syscall.Stat_t
 	_, err := fmt.Sscanf(journalStream, "%d:%d", &expectedStat.Dev, &expectedStat.Ino)
 	if err != nil {
-		return false, fmt.Errorf("failed to parse JOURNAL_STREAM=%q: %v", journalStream, err)
+		return false, fmt.Errorf("failed to parse JOURNAL_STREAM=%q: %w", journalStream, err)
 	}
 
 	var stat syscall.Stat_t

login1/dbus.go

@@ -17,6 +17,7 @@ package login1
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"os"
 	"strconv"
@@ -111,54 +112,52 @@ type User struct {
 	Path dbus.ObjectPath
 }
 
-func sessionFromInterfaces(session []any) (*Session, error) {
+func sessionFromInterfaces(session []any) *Session {
 	if len(session) < 5 {
-		return nil, fmt.Errorf("invalid number of session fields: %d", len(session))
+		return nil
 	}
 	id, ok := session[0].(string)
 	if !ok {
-		return nil, fmt.Errorf("failed to typecast session field 0 to string")
+		return nil
 	}
 	uid, ok := session[1].(uint32)
 	if !ok {
-		return nil, fmt.Errorf("failed to typecast session field 1 to uint32")
+		return nil
 	}
 	user, ok := session[2].(string)
 	if !ok {
-		return nil, fmt.Errorf("failed to typecast session field 2 to string")
+		return nil
 	}
 	seat, ok := session[3].(string)
 	if !ok {
-		return nil, fmt.Errorf("failed to typecast session field 2 to string")
+		return nil
 	}
 	path, ok := session[4].(dbus.ObjectPath)
 	if !ok {
-		return nil, fmt.Errorf("failed to typecast session field 4 to ObjectPath")
+		return nil
 	}
 
-	ret := Session{ID: id, UID: uid, User: user, Seat: seat, Path: path}
-	return &ret, nil
+	return &Session{ID: id, UID: uid, User: user, Seat: seat, Path: path}
 }
 
-func userFromInterfaces(user []any) (*User, error) {
+func userFromInterfaces(user []any) *User {
 	if len(user) < 3 {
-		return nil, fmt.Errorf("invalid number of user fields: %d", len(user))
+		return nil
 	}
 	uid, ok := user[0].(uint32)
 	if !ok {
-		return nil, fmt.Errorf("failed to typecast user field 0 to uint32")
+		return nil
 	}
 	name, ok := user[1].(string)
 	if !ok {
-		return nil, fmt.Errorf("failed to typecast session field 1 to string")
+		return nil
 	}
 	path, ok := user[2].(dbus.ObjectPath)
 	if !ok {
-		return nil, fmt.Errorf("failed to typecast user field 2 to ObjectPath")
+		return nil
 	}
 
-	ret := User{UID: uid, Name: name, Path: path}
-	return &ret, nil
+	return &User{UID: uid, Name: name, Path: path}
 }
 
 // GetActiveSession may be used to get the session object path for the current active session
@@ -175,20 +174,20 @@ func (c *Conn) GetActiveSession() (dbus.ObjectPath, error) {
 	}
 	activeSessionMap, ok := activeSession.Value().([]any)
 	if !ok || len(activeSessionMap) < 2 {
-		return "", fmt.Errorf("failed to typecast active session map")
+		return "", fmt.Errorf("GetActiveSession: can't parse response %+v", activeSession)
 	}
 
 	activeSessionPath, ok := activeSessionMap[1].(dbus.ObjectPath)
 	if !ok {
-		return "", fmt.Errorf("failed to typecast dbus active session Path")
+		return "", fmt.Errorf("GetActiveSession: can't parse response %+v", activeSessionMap)
 	}
 	return activeSessionPath, nil
 }
 
 // GetSessionUser may be used to get the user of specific session
 func (c *Conn) GetSessionUser(sessionPath dbus.ObjectPath) (*User, error) {
 	if len(sessionPath) == 0 {
-		return nil, fmt.Errorf("empty sessionPath")
+		return nil, errors.New("empty sessionPath")
 	}
 
 	activeSessionObj := c.conn.Object(dbusDest, sessionPath)
@@ -203,19 +202,19 @@ func (c *Conn) GetSessionUser(sessionPath dbus.ObjectPath) (*User, error) {
 	}
 	dbusUser, ok := sessionUser.Value().([]any)
 	if !ok {
-		return nil, fmt.Errorf("failed to typecast dbus session user")
+		return nil, fmt.Errorf("GetSessionUser: can't parse response %+v", sessionUser)
 	}
 
 	if len(dbusUser) < 2 {
-		return nil, fmt.Errorf("invalid number of user fields: %d", len(dbusUser))
+		return nil, fmt.Errorf("GetSessionUser: can't parse response %+v", dbusUser)
 	}
 	uid, ok := dbusUser[0].(uint32)
 	if !ok {
-		return nil, fmt.Errorf("failed to typecast user field 0 to uint32")
+		return nil, fmt.Errorf("GetSessionUser: can't parse response %+v", dbusUser)
 	}
 	path, ok := dbusUser[1].(dbus.ObjectPath)
 	if !ok {
-		return nil, fmt.Errorf("failed to typecast user field 1 to ObjectPath")
+		return nil, fmt.Errorf("GetSessionUser: can't parse response %+v", dbusUser)
 	}
 
 	user := User{UID: uid, Name: strings.Trim(sessionUserName.String(), "\""), Path: path}
@@ -226,7 +225,7 @@ func (c *Conn) GetSessionUser(sessionPath dbus.ObjectPath) (*User, error) {
 // GetSessionDisplay may be used to get the display for specific session
 func (c *Conn) GetSessionDisplay(sessionPath dbus.ObjectPath) (string, error) {
 	if len(sessionPath) == 0 {
-		return "", fmt.Errorf("empty sessionPath")
+		return "", errors.New("empty sessionPath")
 	}
 	sessionObj := c.conn.Object(dbusDest, sessionPath)
 	display, err := sessionObj.GetProperty(dbusDest + ".Session.Display")
@@ -246,7 +245,7 @@ func (c *Conn) GetSession(id string) (dbus.ObjectPath, error) {
 
 	ret, ok := out.(dbus.ObjectPath)
 	if !ok {
-		return "", fmt.Errorf("failed to typecast session to ObjectPath")
+		return "", fmt.Errorf("GetSession: can't parse response %+v", out)
 	}
 
 	return ret, nil
@@ -266,9 +265,9 @@ func (c *Conn) ListSessionsContext(ctx context.Context) ([]Session, error) {
 
 	ret := []Session{}
 	for _, el := range out {
-		session, err := sessionFromInterfaces(el)
-		if err != nil {
-			return nil, err
+		session := sessionFromInterfaces(el)
+		if session == nil {
+			return nil, fmt.Errorf("ListSessions: can't parse response %+v", el)
 		}
 		ret = append(ret, *session)
 	}
@@ -289,9 +288,9 @@ func (c *Conn) ListUsersContext(ctx context.Context) ([]User, error) {
 
 	ret := []User{}
 	for _, el := range out {
-		user, err := userFromInterfaces(el)
-		if err != nil {
-			return nil, err
+		user := userFromInterfaces(el)
+		if user == nil {
+			return nil, fmt.Errorf("ListUsers: can't parse response %+v", el)
 		}
 		ret = append(ret, *user)
 	}