Enum greetd_ipc::Response

pub enum Response {
    Success,
    Error {
        error_type: ErrorType,
        description: String,
    },
    AuthMessage {
        auth_message_type: AuthMessageType,
        auth_message: String,
    },
}

A response from greetd to a greeter. The request type is internally tagged with the"type" field, with the type written in snake_case.

Example serialization:

{
   "type": "auth_message",
   "message": "Password:",
   "message_type": "secret"
}

Variants

Success

The request was successful.

Error

The request failed. See the type and/or description for more information about this failure.

Fields of Error

error_type: ErrorTypedescription: String

AuthMessage

An authentication message needs to be answered to continue through the authentication flow.

An authentication message can consist of anything. While it will commonly just be a request for the users' password, it could also ask for TOTP codes, or whether or not you felt sad when Littlefoot's mother died in the original "Land Before Time". It is therefore important that no assumptions are made about the questions that will be asked, and attempts to automatically answer these questions should not be made.

Fields of AuthMessage

auth_message_type: AuthMessageTypeauth_message: String

Trait Implementations

impl Debug for Response

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Response

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl Serialize for Response

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.

impl SyncCodec for Response

fn read_from<T: Read>(stream: &mut T) -> Result<Self, Error>

fn write_to<T: Write>(&self, stream: &mut T) -> Result<(), Error>

impl TokioCodec for Response

fn read_from<'life0, 'async_trait, T: AsyncReadExt + Unpin + Send>(
    stream: &'life0 mut T
) -> Pin<Box<dyn Future<Output = Result<Self, Error>> + Send + 'async_trait>> where
    T: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

fn write_to<'life0, 'life1, 'async_trait, T: AsyncWriteExt + Unpin + Send>(
    &'life0 self,
    stream: &'life1 mut T
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>> where
    T: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait,