errors.go - master - uzer_007/gopcsc

errors.go
307 строк9 KB
uzer_007
Release v1.0.0
03 авг 2026, 13:26
03 авг 2026, 13:2681a16b2
package gopcsc

import (
	"errors"
	"fmt"
)

var (
	ErrCardRemoved        = errors.New("gopcsc: card removed")
	ErrNoCard             = errors.New("gopcsc: no smart card")
	ErrNoReaders          = errors.New("gopcsc: no readers available")
	ErrPermissionDenied   = errors.New("gopcsc: permission denied")
	ErrTimeout            = errors.New("gopcsc: timeout")
	ErrCancelled          = errors.New("gopcsc: cancelled")
	ErrSharingViolation   = errors.New("gopcsc: sharing violation")
	ErrNoService          = errors.New("gopcsc: pc/sc service unavailable")
	ErrServiceStopped     = errors.New("gopcsc: pc/sc service stopped")
	ErrUnknownReader      = errors.New("gopcsc: unknown reader")
	ErrProtocolMismatch   = errors.New("gopcsc: protocol mismatch")
	ErrReaderUnavailable  = errors.New("gopcsc: reader unavailable")
	ErrCommLost           = errors.New("gopcsc: communication lost")
	ErrCardUnsupported    = errors.New("gopcsc: card unsupported")
	ErrUnsupported        = errors.New("gopcsc: unsupported platform")
	ErrUnsupportedFeature = errors.New("gopcsc: unsupported feature")
	ErrInvalidValue       = errors.New("gopcsc: invalid value")
	ErrInsufficientBuffer = errors.New("gopcsc: insufficient buffer")
	ErrProtocol           = errors.New("gopcsc: protocol error")
	ErrAPDUStatus         = errors.New("gopcsc: apdu status")
	ErrContextClosed      = errors.New("gopcsc: context closed")
	ErrCardDisconnected   = errors.New("gopcsc: card disconnected")
	ErrTransactionClosed  = errors.New("gopcsc: transaction closed")
	ErrSessionClosed      = errors.New("gopcsc: session closed")
	ErrRecoveryNeeded     = errors.New("gopcsc: recovery needed")
	ErrReaderSelection    = errors.New("gopcsc: reader selection")
	ErrMonitorClosed      = errors.New("gopcsc: monitor closed")
	ErrMonitorOverflow    = errors.New("gopcsc: monitor overflow")
)

type Error struct {
	Op   string
	Code uint32
}

func (e Error) Error() string {
	name := CodeName(e.Code)
	if e.Op == "" {
		if name != "" {
			return fmt.Sprintf("gopcsc: %s (0x%08x)", name, e.Code)
		}
		return fmt.Sprintf("gopcsc: error 0x%08x", e.Code)
	}
	if name != "" {
		return fmt.Sprintf("gopcsc: %s: %s (0x%08x)", e.Op, name, e.Code)
	}
	return fmt.Sprintf("gopcsc: %s: error 0x%08x", e.Op, e.Code)
}

func (e Error) CodeName() string {
	return CodeName(e.Code)
}

func (e Error) Temporary() bool {
	switch e.Code {
	case SCardETimeout, SCardECancelled, SCardESystemCancelled, SCardESharingViolation,
		SCardENotReady, SCardEReaderUnavailable, SCardPShutdown, SCardEServerTooBusy,
		SCardWUnresponsiveCard, SCardWUnpoweredCard, SCardWResetCard, SCardWRemovedCard:
		return true
	default:
		return false
	}
}

func (e Error) Timeout() bool {
	return e.Code == SCardETimeout
}

func (e Error) Is(target error) bool {
	switch target {
	case ErrCardRemoved:
		return isCardRemovedCode(e.Code)
	case ErrNoCard:
		return e.Code == SCardENoSmartcard
	case ErrNoReaders:
		return e.Code == SCardENoReadersAvailable
	case ErrPermissionDenied:
		return e.Code == SCardWSecurityViolation || e.Code == SCardENoAccess
	case ErrTimeout:
		return e.Code == SCardETimeout
	case ErrCancelled:
		return e.Code == SCardECancelled || e.Code == SCardESystemCancelled
	case ErrSharingViolation:
		return e.Code == SCardESharingViolation
	case ErrNoService:
		return e.Code == SCardENoService || e.Code == SCardEServiceStopped || e.Code == SCardPShutdown
	case ErrServiceStopped:
		return e.Code == SCardEServiceStopped || e.Code == SCardPShutdown
	case ErrUnknownReader:
		return e.Code == SCardEUnknownReader
	case ErrProtocolMismatch:
		return e.Code == SCardEProtoMismatch
	case ErrReaderUnavailable:
		return e.Code == SCardEReaderUnavailable
	case ErrCommLost:
		return e.Code == SCardECommDataLost || e.Code == SCardFCommError
	case ErrCardUnsupported:
		return e.Code == SCardECardUnsupported || e.Code == SCardWUnsupportedCard
	case ErrUnsupportedFeature:
		return e.Code == SCardEUnsupportedFeature || e.Code == SCardEUnsupportedFeaturePCSCLite
	case ErrInvalidValue:
		return e.Code == SCardEInvalidValue || e.Code == SCardEInvalidParameter
	case ErrInsufficientBuffer:
		return e.Code == SCardEInsufficientBuffer || e.Code == SCardEPCISmall
	default:
		return false
	}
}

type ProtocolErrorReason string

const (
	ProtocolReasonTruncatedResponse  ProtocolErrorReason = "truncated response"
	ProtocolReasonInvalidLength      ProtocolErrorReason = "invalid length"
	ProtocolReasonOversizedPayload   ProtocolErrorReason = "oversized payload"
	ProtocolReasonInvalidReaderState ProtocolErrorReason = "invalid reader state"
	ProtocolReasonMalformedResponse  ProtocolErrorReason = "malformed response"
	ProtocolReasonInvalidVersion     ProtocolErrorReason = "invalid version"
)

type ProtocolError struct {
	Op     string
	Reason ProtocolErrorReason
}

func (e ProtocolError) Error() string {
	if e.Op == "" {
		return ErrProtocol.Error() + ": " + string(e.Reason)
	}
	return ErrProtocol.Error() + ": " + e.Op + ": " + string(e.Reason)
}

func (e ProtocolError) Is(target error) bool {
	return target == ErrProtocol
}

type UnsupportedError struct {
	Reason string
}

func (e UnsupportedError) Error() string {
	if e.Reason == "" {
		return ErrUnsupported.Error()
	}
	return ErrUnsupported.Error() + ": " + e.Reason
}

func (e UnsupportedError) Is(target error) bool {
	return target == ErrUnsupported
}

func pcscError(op string, code uint32) error {
	if code == SCardSSuccess {
		return nil
	}
	return Error{Op: op, Code: code}
}

func fmtInvalidValue(reason string) error {
	return fmt.Errorf("%w: %s", ErrInvalidValue, reason)
}

func CodeName(code uint32) string {
	switch code {
	case SCardSSuccess:
		return "SCARD_S_SUCCESS"
	case SCardFInternalError:
		return "SCARD_F_INTERNAL_ERROR"
	case SCardECancelled:
		return "SCARD_E_CANCELLED"
	case SCardEInvalidHandle:
		return "SCARD_E_INVALID_HANDLE"
	case SCardEInvalidParameter:
		return "SCARD_E_INVALID_PARAMETER"
	case SCardEInvalidTarget:
		return "SCARD_E_INVALID_TARGET"
	case SCardENoMemory:
		return "SCARD_E_NO_MEMORY"
	case SCardFWaitedTooLong:
		return "SCARD_F_WAITED_TOO_LONG"
	case SCardEInsufficientBuffer:
		return "SCARD_E_INSUFFICIENT_BUFFER"
	case SCardEUnknownReader:
		return "SCARD_E_UNKNOWN_READER"
	case SCardETimeout:
		return "SCARD_E_TIMEOUT"
	case SCardESharingViolation:
		return "SCARD_E_SHARING_VIOLATION"
	case SCardENoSmartcard:
		return "SCARD_E_NO_SMARTCARD"
	case SCardEUnknownCard:
		return "SCARD_E_UNKNOWN_CARD"
	case SCardECantDispose:
		return "SCARD_E_CANT_DISPOSE"
	case SCardEProtoMismatch:
		return "SCARD_E_PROTO_MISMATCH"
	case SCardENotReady:
		return "SCARD_E_NOT_READY"
	case SCardEInvalidValue:
		return "SCARD_E_INVALID_VALUE"
	case SCardESystemCancelled:
		return "SCARD_E_SYSTEM_CANCELLED"
	case SCardFCommError:
		return "SCARD_F_COMM_ERROR"
	case SCardFUnknownError:
		return "SCARD_F_UNKNOWN_ERROR"
	case SCardEInvalidATR:
		return "SCARD_E_INVALID_ATR"
	case SCardENotTransacted:
		return "SCARD_E_NOT_TRANSACTED"
	case SCardEReaderUnavailable:
		return "SCARD_E_READER_UNAVAILABLE"
	case SCardPShutdown:
		return "SCARD_P_SHUTDOWN"
	case SCardEPCISmall:
		return "SCARD_E_PCI_TOO_SMALL"
	case SCardEReaderUnsupported:
		return "SCARD_E_READER_UNSUPPORTED"
	case SCardEDuplicateReader:
		return "SCARD_E_DUPLICATE_READER"
	case SCardECardUnsupported:
		return "SCARD_E_CARD_UNSUPPORTED"
	case SCardENoService:
		return "SCARD_E_NO_SERVICE"
	case SCardEServiceStopped:
		return "SCARD_E_SERVICE_STOPPED"
	case SCardEUnexpected:
		return "SCARD_E_UNEXPECTED"
	case SCardEUnsupportedFeature:
		return "SCARD_E_UNSUPPORTED_FEATURE"
	case SCardEICCInstallation:
		return "SCARD_E_ICC_INSTALLATION"
	case SCardEICCCreateOrder:
		return "SCARD_E_ICC_CREATEORDER"
	case SCardEDirNotFound:
		return "SCARD_E_DIR_NOT_FOUND"
	case SCardEFileNotFound:
		return "SCARD_E_FILE_NOT_FOUND"
	case SCardENoDir:
		return "SCARD_E_NO_DIR"
	case SCardENoFile:
		return "SCARD_E_NO_FILE"
	case SCardENoAccess:
		return "SCARD_E_NO_ACCESS"
	case SCardEWriteTooMany:
		return "SCARD_E_WRITE_TOO_MANY"
	case SCardEBadSeek:
		return "SCARD_E_BAD_SEEK"
	case SCardEInvalidCHV:
		return "SCARD_E_INVALID_CHV"
	case SCardEUnknownResMsg:
		return "SCARD_E_UNKNOWN_RES_MNG"
	case SCardENoSuchCertificate:
		return "SCARD_E_NO_SUCH_CERTIFICATE"
	case SCardECertificateUnavailable:
		return "SCARD_E_CERTIFICATE_UNAVAILABLE"
	case SCardENoReadersAvailable:
		return "SCARD_E_NO_READERS_AVAILABLE"
	case SCardECommDataLost:
		return "SCARD_E_COMM_DATA_LOST"
	case SCardENoKeyContainer:
		return "SCARD_E_NO_KEY_CONTAINER"
	case SCardEServerTooBusy:
		return "SCARD_E_SERVER_TOO_BUSY"
	case SCardWUnsupportedCard:
		return "SCARD_W_UNSUPPORTED_CARD"
	case SCardWUnresponsiveCard:
		return "SCARD_W_UNRESPONSIVE_CARD"
	case SCardWUnpoweredCard:
		return "SCARD_W_UNPOWERED_CARD"
	case SCardWResetCard:
		return "SCARD_W_RESET_CARD"
	case SCardWRemovedCard:
		return "SCARD_W_REMOVED_CARD"
	case SCardWSecurityViolation:
		return "SCARD_W_SECURITY_VIOLATION"
	case SCardWWrongCHV:
		return "SCARD_W_WRONG_CHV"
	case SCardWCHVBlocked:
		return "SCARD_W_CHV_BLOCKED"
	case SCardWEOF:
		return "SCARD_W_EOF"
	case SCardWCancelledByUser:
		return "SCARD_W_CANCELLED_BY_USER"
	case SCardWCardNotAuthenticated:
		return "SCARD_W_CARD_NOT_AUTHENTICATED"
	default:
		return ""
	}
}

func isCardRemovedCode(code uint32) bool {
	switch code {
	case SCardENoSmartcard, SCardWRemovedCard, SCardWUnpoweredCard, SCardWResetCard:
		return true
	default:
		return false
	}
}