1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

// Copyright (c) 2019, Arm Limited, All Rights Reserved
// SPDX-License-Identifier: Apache-2.0
//
// Licensed under the Apache License, Version 2.0 (the "License"); you may
// not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//          http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//! # Rust representation of operations
//!
//! Rust native representation of the language neutral operations described in the
//! [Operations](https://parallaxsecond.github.io/parsec-book/parsec_client/operations/index.html)
//! page in the book.
mod ping;
pub mod key_attributes;
mod create_key;
mod import_key;
mod export_public_key;
mod destroy_key;
mod asym_sign;
mod asym_verify;
mod list_opcodes;
mod list_providers;

use crate::requests::{request::RequestBody, response::ResponseBody, Opcode, Result};
pub use asym_sign::{OpAsymSign, ResultAsymSign};
pub use asym_verify::{OpAsymVerify, ResultAsymVerify};
pub use create_key::{OpCreateKey, ResultCreateKey};
pub use destroy_key::{OpDestroyKey, ResultDestroyKey};
pub use export_public_key::{OpExportPublicKey, ResultExportPublicKey};
pub use import_key::{OpImportKey, ResultImportKey};
pub use list_opcodes::{OpListOpcodes, ResultListOpcodes};
pub use list_providers::{OpListProviders, ProviderInfo, ResultListProviders};
pub use ping::{OpPing, ResultPing};

/// Container type for operation conversion values, holding a native operation object
/// to be passed in/out of a converter.
#[derive(Debug)]
pub enum NativeOperation {
    ListProviders(OpListProviders),
    ListOpcodes(OpListOpcodes),
    Ping(OpPing),
    CreateKey(OpCreateKey),
    ImportKey(OpImportKey),
    ExportPublicKey(OpExportPublicKey),
    DestroyKey(OpDestroyKey),
    AsymSign(OpAsymSign),
    AsymVerify(OpAsymVerify),
}

impl NativeOperation {
    pub fn opcode(&self) -> Opcode {
        match self {
            NativeOperation::Ping(_) => Opcode::Ping,
            NativeOperation::CreateKey(_) => Opcode::CreateKey,
            NativeOperation::DestroyKey(_) => Opcode::DestroyKey,
            NativeOperation::AsymSign(_) => Opcode::AsymSign,
            NativeOperation::AsymVerify(_) => Opcode::AsymVerify,
            NativeOperation::ImportKey(_) => Opcode::ImportKey,
            NativeOperation::ExportPublicKey(_) => Opcode::ExportPublicKey,
            NativeOperation::ListOpcodes(_) => Opcode::ListOpcodes,
            NativeOperation::ListProviders(_) => Opcode::ListProviders,
        }
    }
}

/// Container type for result conversion values, holding a native result object to be
/// passed in/out of the converter.
#[derive(Debug)]
pub enum NativeResult {
    ListProviders(ResultListProviders),
    ListOpcodes(ResultListOpcodes),
    Ping(ResultPing),
    CreateKey(ResultCreateKey),
    ImportKey(ResultImportKey),
    ExportPublicKey(ResultExportPublicKey),
    DestroyKey(ResultDestroyKey),
    AsymSign(ResultAsymSign),
    AsymVerify(ResultAsymVerify),
}

impl NativeResult {
    pub fn opcode(&self) -> Opcode {
        match self {
            NativeResult::Ping(_) => Opcode::Ping,
            NativeResult::CreateKey(_) => Opcode::CreateKey,
            NativeResult::DestroyKey(_) => Opcode::DestroyKey,
            NativeResult::AsymSign(_) => Opcode::AsymSign,
            NativeResult::AsymVerify(_) => Opcode::AsymVerify,
            NativeResult::ImportKey(_) => Opcode::ImportKey,
            NativeResult::ExportPublicKey(_) => Opcode::ExportPublicKey,
            NativeResult::ListOpcodes(_) => Opcode::ListOpcodes,
            NativeResult::ListProviders(_) => Opcode::ListProviders,
        }
    }
}

/// Definition of the operations converters must implement to allow usage of a specific
/// `BodyType`.
pub trait Convert {
    /// Create a native operation object from a request body.
    ///
    /// # Errors
    /// - if deserialization fails, `ResponseStatus::DeserializingBodyFailed` is returned
    fn body_to_operation(&self, body: RequestBody, opcode: Opcode) -> Result<NativeOperation>;

    /// Create a request body from a native operation object.
    ///
    /// # Errors
    /// - if serialization fails, `ResponseStatus::SerializingBodyFailed` is returned
    fn operation_to_body(&self, operation: NativeOperation) -> Result<RequestBody>;

    /// Create a native result object from a response body.
    ///
    /// # Errors
    /// - if deserialization fails, `ResponseStatus::DeserializingBodyFailed` is returned
    fn body_to_result(&self, body: ResponseBody, opcode: Opcode) -> Result<NativeResult>;

    /// Create a response body from a native result object.
    ///
    /// # Errors
    /// - if serialization fails, `ResponseStatus::SerializingBodyFailed` is returned
    fn result_to_body(&self, result: NativeResult) -> Result<ResponseBody>;
}