Enum steamworks::SteamError

pub enum SteamError {
    InitFailed,
    Generic,
    NoConnection,
    InvalidPassword,
    LoggedInElsewhere,
    InvalidProtocolVersion,
    InvalidParameter,
    FileNotFound,
    Busy,
    InvalidState,
    InvalidName,
    InvalidEmail,
    DuplicateName,
    AccessDenied,
    Timeout,
    Banned,
    AccountNotFound,
    InvalidSteamID,
    ServiceUnavailable,
    NotLoggedOn,
    Pending,
    EncryptionFailure,
    InsufficientPrivilege,
    LimitExceeded,
    Revoked,
    Expired,
    AlreadyRedeemed,
    DuplicateRequest,
    AlreadyOwned,
    IPNotFound,
    PersistFailed,
    LockingFailed,
    LogonSessionReplaced,
    ConnectFailed,
    HandshakeFailed,
    IOFailure,
    RemoteDisconnect,
    ShoppingCartNotFound,
    Blocked,
    Ignored,
    NoMatch,
    AccountDisabled,
    ServiceReadOnly,
    AccountNotFeatured,
    AdministratorOK,
    ContentVersion,
    TryAnotherCM,
    PasswordRequiredToKickSession,
    AlreadyLoggedInElsewhere,
    Suspended,
    Cancelled,
    DataCorruption,
    DiskFull,
    RemoteCallFailed,
    PasswordUnset,
    ExternalAccountUnlinked,
    PSNTicketInvalid,
    ExternalAccountAlreadyLinked,
    RemoteFileConflict,
    IllegalPassword,
    SameAsPreviousValue,
    AccountLogonDenied,
    CannotUseOldPassword,
    InvalidLoginAuthCode,
    AccountLogonDeniedNoMail,
    HardwareNotCapableOfIPT,
    IPTInitError,
    ParentalControlRestricted,
    FacebookQueryError,
    ExpiredLoginAuthCode,
    IPLoginRestrictionFailed,
    AccountLockedDown,
    AccountLogonDeniedVerifiedEmailRequired,
    NoMatchingURL,
    BadResponse,
    RequirePasswordReEntry,
    ValueOutOfRange,
    UnexpectedError,
    Disabled,
    InvalidCEGSubmission,
    RestrictedDevice,
    RegionLocked,
    RateLimitExceeded,
    AccountLoginDeniedNeedTwoFactor,
    ItemDeleted,
    AccountLoginDeniedThrottle,
    TwoFactorCodeMismatch,
    TwoFactorActivationCodeMismatch,
    AccountAssociatedToMultiplePartners,
    NotModified,
    NoMobileDevice,
    TimeNotSynced,
    SmsCodeFailed,
    AccountLimitExceeded,
    AccountActivityLimitExceeded,
    PhoneActivityLimitExceeded,
    RefundToWallet,
    EmailSendFailure,
    NotSettled,
    NeedCaptcha,
    GSLTDenied,
    GSOwnerDenied,
    InvalidItemType,
    IPBanned,
    GSLTExpired,
    InsufficientFunds,
    TooManyPending,
    NoSiteLicensesFound,
    WGNetworkSendExceeded,
    AccountNotFriends,
    LimitedUserAccount,
}

Covers errors that can be returned by the steamworks API

Documentation is based on official documentation which doesn't always explain when an error could be returned or its meaning.

Variants

InitFailed

Returned if the steamworks API fails to initialize.

Generic

Returned if the steamworks API fails to perform an action

NoConnection

Returned when steam fails performing a network request

InvalidPassword

Return when the password or ticked used is invalid

LoggedInElsewhere

Returned when the user is already logged in at another location

InvalidProtocolVersion

Returned when the protocol version is incorrect

InvalidParameter

Returned when a passed parameter is invalid

FileNotFound

Returned when a file is not found

Busy

Returned when the called method was busy

No action was performed

InvalidState

Returned when the called object was in an invalid state

InvalidName

Returned when the name is invalid

InvalidEmail

Returned when the email is invalid

DuplicateName

Returned when the name is not unique

AccessDenied

Returned when access is denied

Timeout

Returned when the operation timed out

Banned

Returned when the user is VAC2 banned

AccountNotFound

Returned when the account is not found

InvalidSteamID

Returned when the passed steam id is invalid

ServiceUnavailable

Returned when the requested service in unavailable

NotLoggedOn

Returned when the user is not logged on

Pending

Returned when the request is pending (e.g. in progress/waiting)

EncryptionFailure

Returned when encryption or decryption fails

InsufficientPrivilege

Returned when you have insufficient privilege to perform the action

LimitExceeded

Returned when you have hit the API limits

Revoked

Returned when the user's access has been revoked (e.g. revoked guess passes)

Expired

Returned when the user's access has expired

AlreadyRedeemed

Returned when the licence/guest pass has already been redeemed

DuplicateRequest

Returned when the requested action is a duplicate and has already occurred.

The action will be ignored

AlreadyOwned

Returned when all the games in the guest pass are already owned by the user

IPNotFound

Returned when the ip address is not found

PersistFailed

Returned when the change failed to write to the data store

LockingFailed

Returned when the operation failed to acquire the access lock

LogonSessionReplaced

Undocumented

ConnectFailed

Undocumented

HandshakeFailed

Undocumented

IOFailure

Undocumented

RemoteDisconnect

Undocumented

ShoppingCartNotFound

Returned when the requested shopping cart wasn't found

Blocked

Returned when the user blocks an action

Ignored

Returned when the target user is ignoring the sender

NoMatch

Returned when nothing matching the request is found

AccountDisabled

Undocumented

ServiceReadOnly

Returned when the service isn't accepting content changes at this moment

AccountNotFeatured

Returned when the account doesn't have value so the feature isn't available

AdministratorOK

Allowed to take this action but only because the requester is an admin

ContentVersion

Returned when there is a version mismatch in content transmitted within the steam protocol

TryAnotherCM

Returned when the current CM cannot service the user's request.

The user should try another.

PasswordRequiredToKickSession

Returned when the user is already logged in elsewhere and the cached credential login failed.

AlreadyLoggedInElsewhere

Returned when the user is already logged in elsewhere, you must wait before trying again

Suspended

Returned when a long running operation (e.g. download) is suspended/paused.

Cancelled

Returned when an operation is cancelled

DataCorruption

Returned when an operation is cancelled due to data corruption

DiskFull

Returned when an operation is cancelled due to running out of disk space

RemoteCallFailed

Returned when a remote call or an IPC call failed

PasswordUnset

Returned when a password could not be verified as its unset server side

ExternalAccountUnlinked

Returned when the external account is not linked to a steam account

PSNTicketInvalid

Returned when the PSN ticket is invalid

ExternalAccountAlreadyLinked

Returned when the external account is already linked to a steam account

RemoteFileConflict

Returned when sync cannot resume due to a file conflict

IllegalPassword

Returned when the requested new password is not legal

SameAsPreviousValue

Returned when the new value is the same as the previous value

AccountLogonDenied

Returned when the account logon is denied to 2nd factor authentication failure

CannotUseOldPassword

Returned when the requested new password is the same as the previous password

InvalidLoginAuthCode

Returned when logging in is denied due to an invalid auth code

AccountLogonDeniedNoMail

Returned when logging in fails due to no email being set for 2nd factor authentication

HardwareNotCapableOfIPT

Undocumented

IPTInitError

Undocumented

ParentalControlRestricted

Returned when a operation fails due to parental control restrictions for a user

FacebookQueryError

Returned when a facebook query returns an error

ExpiredLoginAuthCode

Returned when account login is denied due to an expired auth code

IPLoginRestrictionFailed

Undocumented

AccountLockedDown

Undocumented

AccountLogonDeniedVerifiedEmailRequired

Undocumented

NoMatchingURL

Undocumented

BadResponse

Returned when something fails to parse/has a missing field

RequirePasswordReEntry

Returned when a user cannot complete the action until they re-enter their password

ValueOutOfRange

Returned when an entered value is outside the acceptable range

UnexpectedError

Returned when an error happens that the steamworks API didn't expect to happen

Disabled

Returned when the requested service is disabled

InvalidCEGSubmission

Returned when the set of files submitted to the CEG server are not valid

RestrictedDevice

Returned when the device being used is not allowed to perform this action

RegionLocked

Returned when an action is prevented due to region restrictions

RateLimitExceeded

Returned when an action failed due to a temporary rate limit

AccountLoginDeniedNeedTwoFactor

Returned when a account needs to use a two-factor code to login

ItemDeleted

Returned when the item attempting to be accessed has been deleted

AccountLoginDeniedThrottle

Returned when the account login failed and you should throttle the response to the possible attacker

TwoFactorCodeMismatch

Returned when the two factor code provided mismatched the expected one

TwoFactorActivationCodeMismatch

Returned when the two factor activation code mismatched the expected one

AccountAssociatedToMultiplePartners

Returned when the account has been associated with multiple partners

NotModified

Returned when the data wasn't modified

NoMobileDevice

Returned when the account doesn't have a mobile device associated with it

TimeNotSynced

Returned when the current time is out of range or tolerance

SmsCodeFailed

Returned when the sms code failed to validate

AccountLimitExceeded

Returned when too many accounts are accessing the requested resource

AccountActivityLimitExceeded

Returned when there have been too many changes to the account

PhoneActivityLimitExceeded

Returned when there have been too many changes to the phone

RefundToWallet

Returned when the refund can not be sent to the payment method and the steam wallet must be used

EmailSendFailure

Returned when steam failed to send an email

NotSettled

Returned when an action cannot be performed until the payment has settled

NeedCaptcha

Returned when the user needs to provide a valid captcha

GSLTDenied

Returned when the game server login token owned by the token's owner been banned

GSOwnerDenied

Returned when the game server owner has been denied for other reasons (account lock, community ban, vac ban, missing phone)

InvalidItemType

Returned when the type of item attempted to be acted on is invalid

IPBanned

Returned when the IP address has been banned for taking this action

GSLTExpired

Returned when the game server login token has expired

It can be reset for use

InsufficientFunds

Returned when the user does not have the wallet funds to complete the action

TooManyPending

Returned when there are too many of the requested action pending already

NoSiteLicensesFound

Returned when there is no site licenses found

WGNetworkSendExceeded

Returned when WG could not send a response because it exceeded the max network send size

AccountNotFriends

Returned when the account is not mutually friends with the user

LimitedUserAccount

Returned when the user is limited

Trait Implementations

impl Debug for SteamError

fn fmt(&self, __arg_0: &mut Formatter) -> Result

Formats the value using the given formatter.

impl Fail for SteamError

fn cause(&self) -> Option<&Fail>

Returns a reference to the underlying cause of this failure, if it is an error that wraps other errors.

fn backtrace(&self) -> Option<&Backtrace>

Returns a reference to the Backtrace carried by this failure, if it carries one.

fn context<D>(self, context: D) -> Context<D> where
    D: Display + Send + Sync + 'static, 

Provides context for this failure.

fn compat(self) -> Compat<Self>

Wraps this failure in a compatibility wrapper that implements std::error::Error.

fn causes(&self) -> Causes

Returns a iterator over the causes of this Fail with itself as the first item and the root_cause as the final item.

fn root_cause(&self) -> &(Fail + 'static)

Returns the "root cause" of this Fail - the last value in the cause chain which does not return an underlying cause.

impl Display for SteamError

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl From<SResult> for SteamError

fn from(r: SResult) -> Self

Performs the conversion.