602 lines
20 KiB
Rust
602 lines
20 KiB
Rust
use std::ops;
|
|
use super::types::*;
|
|
use crate::types::traits::*;
|
|
use crate::types::{ReturnType, SSKKeypair, SSK, USK, KEY};
|
|
use regex::Regex;
|
|
|
|
impl ClientHello {
|
|
pub fn new(name: String, exp_ver: f32) -> Self {
|
|
ClientHello {
|
|
name: name,
|
|
expected_version: exp_ver,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl FcpRequest for ClientHello {
|
|
fn convert(&self) -> String {
|
|
return format!(
|
|
"ClientHello\n\
|
|
Name={}\n\
|
|
ExpectedVersion={:?}\n\
|
|
EndMessage\n\n",
|
|
self.name, self.expected_version
|
|
);
|
|
}
|
|
}
|
|
|
|
pub struct ClientHello {
|
|
name: String,
|
|
expected_version: f32,
|
|
}
|
|
|
|
#[test]
|
|
fn client_hello_converts() {
|
|
let hello = ClientHello::new("user name".to_string(), 2.0);
|
|
assert_eq!(
|
|
hello.convert(),
|
|
"ClientHello\nName=user name\nExpectedVersion=2.0\nEndMessage\n\n"
|
|
);
|
|
}
|
|
|
|
// TODO not implemented ListPeer
|
|
pub struct ListPeer {
|
|
message_name: String,
|
|
node_identifier: NodeIdentifier,
|
|
with_volatile: Option<bool>,
|
|
with_metadata: Option<bool>,
|
|
}
|
|
pub struct ListPeers {
|
|
message_name: String,
|
|
with_volatile: Option<bool>,
|
|
with_metadata: Option<bool>,
|
|
}
|
|
|
|
pub struct ListPeerNotes {
|
|
message_name: String,
|
|
node_identifier: NodeIdentifier,
|
|
}
|
|
pub struct AddPeer {
|
|
message_name: String,
|
|
trust: TrustLevel,
|
|
visibility: VisibilityLevel,
|
|
file: Option<String>,
|
|
url: Option<String>,
|
|
raw: Option<String>,
|
|
}
|
|
pub struct ModifyPeer {
|
|
message_name: String,
|
|
node_identifier: NodeIdentifier,
|
|
allow_local_addresses: Option<bool>,
|
|
is_disabled: Option<bool>,
|
|
is_listen_only: Option<bool>,
|
|
is_burst_only: Option<bool>,
|
|
ignore_source_port: Option<bool>,
|
|
}
|
|
pub struct ModifyPeerNote {
|
|
message_name: String,
|
|
node_text: String,
|
|
peer_note_type: i32,
|
|
}
|
|
pub struct RemovePeer {
|
|
message_name: String,
|
|
node_identifier: NodeIdentifier,
|
|
}
|
|
|
|
pub struct GetNode {
|
|
message_name: String,
|
|
identifier: Option<bool>,
|
|
give_opennet_ref: Option<bool>,
|
|
with_private: Option<bool>,
|
|
with_volatile: Option<bool>,
|
|
}
|
|
|
|
pub struct GenerateSSK {
|
|
pub identifier: Option<String>,
|
|
}
|
|
|
|
impl FcpRequest for GenerateSSK {
|
|
fn convert(&self) -> String {
|
|
let identifier = to_fcp_unwrap("Identifier=", &self.identifier, "\n");
|
|
format!(
|
|
"GenerateSSK\n\
|
|
{}\
|
|
EndMessage\n\n",
|
|
identifier
|
|
)
|
|
}
|
|
}
|
|
|
|
//SSK@Rgt0qM8D24DltliV2-JE9tYLcrgGAKeDwkz41I3JBPs,p~c8c7FXcJjhcf2vA-Xm0Mjyw1o~xn7L2-T8zlBA1IU,AQECAAE/
|
|
//SSK@uKTwaQIXNgsCYKLekb51t3pZ6A~PTP7nuCxRVZEMtCQ,p~c8c7FXcJjhcf2vA-Xm0Mjyw1o~xn7L2-T8zlBA1IU,AQACAAE/
|
|
/*
|
|
SSKKeypair
|
|
Identifier=34
|
|
InsertURI=SSK@Rgt0qM8D24DltliV2-JE9tYLcrgGAKeDwkz41I3JBPs,p~c8c7FXcJjhcf2vA-Xm0Mjyw1o~xn7L2-T8zlBA1IU,AQECAAE/
|
|
RequestURI=SSK@uKTwaQIXNgsCYKLekb51t3pZ6A~PTP7nuCxRVZEMtCQ,p~c8c7FXcJjhcf2vA-Xm0Mjyw1o~xn7L2-T8zlBA1IU,AQACAAE/
|
|
EndMessage
|
|
*/
|
|
#[test]
|
|
fn is_keypair_parsing() {
|
|
let parsed = SSKKeypair::parse("SSKKeypair\n\
|
|
Identifier=name\n\
|
|
InsertURI=SSK@Rgt0qM8D24DltliV2-JE9tYLcrgGAKeDwkz41I3JBPs,p~c8c7FXcJjhcf2vA-Xm0Mjyw1o~xn7L2-T8zlBA1IU,AQECAAE/\n\
|
|
RequestURI=SSK@uKTwaQIXNgsCYKLekb51t3pZ6A~PTP7nuCxRVZEMtCQ,p~c8c7FXcJjhcf2vA-Xm0Mjyw1o~xn7L2-T8zlBA1IU,AQACAAE/\n\
|
|
EndMessage\n");
|
|
assert_eq!(
|
|
SSKKeypair {
|
|
insert_uri: SSK {
|
|
sign_key: "Rgt0qM8D24DltliV2-JE9tYLcrgGAKeDwkz41I3JBPs".to_string(),
|
|
decrypt_key: "p~c8c7FXcJjhcf2vA-Xm0Mjyw1o~xn7L2-T8zlBA1IU".to_string(),
|
|
settings: Some("AQECAAE".to_string())
|
|
},
|
|
request_uri: SSK {
|
|
sign_key: "uKTwaQIXNgsCYKLekb51t3pZ6A~PTP7nuCxRVZEMtCQ".to_string(),
|
|
decrypt_key: "p~c8c7FXcJjhcf2vA-Xm0Mjyw1o~xn7L2-T8zlBA1IU".to_string(),
|
|
settings: Some("AQACAAE".to_string()),
|
|
},
|
|
identifier: "name".to_string(),
|
|
},
|
|
parsed.unwrap()
|
|
)
|
|
}
|
|
|
|
impl FcpParser<SSK> for SSK {
|
|
fn parse(plain: &str) -> Option<SSK> {
|
|
let reg1 = Regex::new(r".*?SSK@([a-zA-z0-9~-]*),([a-zA-Z0-9-~]*),([A-Z]*)").unwrap();
|
|
//let reg2 = Regex::new(r"^.*?\w{3}@(.*),(.*)/").unwrap();
|
|
let reg2 = Regex::new(r".*?SSK@([a-zA-z0-9~-]*),([a-zA-Z0-9-~]*)").unwrap();
|
|
match reg1.captures(plain) {
|
|
Some(reg) => Some(SSK {
|
|
sign_key: reg[1].to_string(),
|
|
decrypt_key: reg[2].to_string(),
|
|
settings: Some(reg[3].to_string()),
|
|
}),
|
|
None => match reg2.captures(plain) {
|
|
Some(reg) => Some(SSK {
|
|
sign_key: reg[1].to_string(),
|
|
decrypt_key: reg[2].to_string(),
|
|
settings: None,
|
|
}),
|
|
None => None,
|
|
},
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn is_ssk_parsing() {
|
|
// SSK@AKTTKG6YwjrHzWo67laRcoPqibyiTdyYufjVg54fBlWr,AwUSJG5ZS-FDZTqnt6skTzhxQe08T-fbKXj8aEHZsXM/
|
|
// SSK@BnHXXv3Fa43w~~iz1tNUd~cj4OpUuDjVouOWZ5XlpX0,AwUSJG5ZS-FDZTqnt6skTzhxQe08T-fbKXj8aEHZsXM,AQABAAE
|
|
let ssk = SSK::parse("SSK@AKTTKG6YwjrHzWo67laRcoPqibyiTdyYufjVg54fBlWr,AwUSJG5ZS-FDZTqnt6skTzhxQe08T-fbKXj8aEHZsXM/").unwrap();
|
|
let ssk2 = SSK::parse("SSK@BnHXXv3Fa43w~~iz1tNUd~cj4OpUuDjVouOWZ5XlpX0,AwUSJG5ZS-FDZTqnt6skTzhxQe08T-fbKXj8aEHZsXM,AQABAAE").unwrap();
|
|
|
|
assert_eq!(
|
|
ssk,
|
|
SSK {
|
|
sign_key: "AKTTKG6YwjrHzWo67laRcoPqibyiTdyYufjVg54fBlWr".to_string(),
|
|
decrypt_key: "AwUSJG5ZS-FDZTqnt6skTzhxQe08T-fbKXj8aEHZsXM".to_string(),
|
|
settings: None
|
|
}
|
|
);
|
|
assert_eq!(
|
|
ssk2,
|
|
SSK {
|
|
sign_key: "BnHXXv3Fa43w~~iz1tNUd~cj4OpUuDjVouOWZ5XlpX0".to_string(),
|
|
decrypt_key: "AwUSJG5ZS-FDZTqnt6skTzhxQe08T-fbKXj8aEHZsXM".to_string(),
|
|
settings: Some("AQABAAE".to_string()),
|
|
}
|
|
);
|
|
}
|
|
|
|
impl FcpRequest for KEY {
|
|
fn convert(&self) -> String{
|
|
match self {
|
|
KEY::SSK(key) => key.convert(),
|
|
KEY::USK(key) => key.convert()
|
|
}
|
|
}
|
|
}
|
|
|
|
// TODO Create just Key type which contains from sign_key, decrtypt_key, settings and path.
|
|
// And use it for all keys, like SSK, USK e.t.c.
|
|
/// converting SSK key to string
|
|
impl FcpRequest for SSK {
|
|
fn convert(&self) -> String {
|
|
let mut settings: String = "".to_string();
|
|
match &self.settings {
|
|
Some(res) => settings = format!(",{}", res),
|
|
_ => {}
|
|
}
|
|
format!("SSK@{},{}{}", self.sign_key, self.decrypt_key, settings)
|
|
}
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
fn is_ssk_converting() {
|
|
assert_eq!(SSK {
|
|
sign_key: "AKTTKG6YwjrHzWo67laRcoPqibyiTdyYufjVg54fBlWr".to_string(),
|
|
decrypt_key: "AwUSJG5ZS-FDZTqnt6skTzhxQe08T-fbKXj8aEHZsXM".to_string(),
|
|
settings: None
|
|
}.convert(), "SSK@AKTTKG6YwjrHzWo67laRcoPqibyiTdyYufjVg54fBlWr,AwUSJG5ZS-FDZTqnt6skTzhxQe08T-fbKXj8aEHZsXM");
|
|
assert_eq!(SSK {
|
|
sign_key: "BnHXXv3Fa43w~~iz1tNUd~cj4OpUuDjVouOWZ5XlpX0".to_string(),
|
|
decrypt_key: "AwUSJG5ZS-FDZTqnt6skTzhxQe08T-fbKXj8aEHZsXM".to_string(),
|
|
settings: Some("AQABAAE".to_string()),
|
|
}.convert(), "SSK@BnHXXv3Fa43w~~iz1tNUd~cj4OpUuDjVouOWZ5XlpX0,AwUSJG5ZS-FDZTqnt6skTzhxQe08T-fbKXj8aEHZsXM,AQABAAE")
|
|
}
|
|
/// converting USK key to string
|
|
impl FcpRequest for USK {
|
|
fn convert(&self) -> String {
|
|
let mut settings: String = "".to_string();
|
|
//There's no might be settings for key, and we skipping it
|
|
match &self.ssk.settings {
|
|
Some(res) => settings = format!(",{}", res),
|
|
_ => {}
|
|
}
|
|
format!(
|
|
"USK@{},{}{}/{}",
|
|
self.ssk.sign_key, self.ssk.decrypt_key, settings, self.path
|
|
)
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn is_usk_converting() {
|
|
assert_eq!(
|
|
USK {
|
|
ssk: SSK {
|
|
sign_key: "AKTTKG6YwjrHzWo67laRcoPqibyiTdyYufjVg54fBlWr".to_string(),
|
|
decrypt_key: "AwUSJG5ZS-FDZTqnt6skTzhxQe08T-fbKXj8aEHZsXM".to_string(),
|
|
settings: None
|
|
},
|
|
path: "messages/0".to_string()
|
|
}
|
|
.convert(), "USK@AKTTKG6YwjrHzWo67laRcoPqibyiTdyYufjVg54fBlWr,AwUSJG5ZS-FDZTqnt6skTzhxQe08T-fbKXj8aEHZsXM/messages/0");
|
|
assert_eq!(
|
|
USK{ ssk:
|
|
SSK {
|
|
sign_key: "BnHXXv3Fa43w~~iz1tNUd~cj4OpUuDjVouOWZ5XlpX0".to_string(),
|
|
decrypt_key: "AwUSJG5ZS-FDZTqnt6skTzhxQe08T-fbKXj8aEHZsXM".to_string(),
|
|
settings: Some("AQABAAE".to_string()),
|
|
},
|
|
path: "messages/0".to_string()
|
|
}
|
|
.convert(), "USK@BnHXXv3Fa43w~~iz1tNUd~cj4OpUuDjVouOWZ5XlpX0,AwUSJG5ZS-FDZTqnt6skTzhxQe08T-fbKXj8aEHZsXM,AQABAAE/messages/0")
|
|
}
|
|
|
|
impl SSKKeypair {
|
|
/*
|
|
fn parse(plain: String) -> Self {
|
|
let lines = plain.lines();
|
|
let insert_uri = lines.next().unwrap_or("");
|
|
let request_uri = lines.next().unwrap_or("");
|
|
let identifier = lines.next().unwrap_or("");
|
|
}
|
|
*/
|
|
}
|
|
|
|
pub struct ClientPut {
|
|
uri: USK, //TODO create key type
|
|
data_length: usize,
|
|
filename: Option<String>,
|
|
content_type: Option<String>,
|
|
identifier: String,
|
|
verbosity: Option<VerbosityPut>,
|
|
max_retries: Option<Retry>,
|
|
priority_class: Option<Priority>,
|
|
get_chk_only: Option<bool>,
|
|
global: Option<bool>,
|
|
dont_compress: Option<bool>,
|
|
codecs: Option<String>, // TODO turn into vec and add implementation
|
|
client_token: Option<String>,
|
|
persistence: Option<Persistence>,
|
|
target_filename: Option<String>, // TODO create filename type ( not PATH, ONLY SLASHES)
|
|
early_encode: Option<bool>,
|
|
upload_from: Option<UploadForm>,
|
|
target_uri: Option<String>, // cloning uri if does not exists
|
|
file_hash: Option<String>, //TODO SHAA256 type
|
|
binary_blob: Option<bool>,
|
|
fork_on_cacheable: Option<bool>,
|
|
extra_inserts_single_block: Option<u32>,
|
|
extra_inserts_splitfile_header_block: Option<u32>,
|
|
compatibility_mode: Option<String>, //TODO create enum???
|
|
local_request_only: Option<bool>,
|
|
override_splitfile_crypto_key: Option<String>, //key in hex
|
|
real_time_flag: Option<String>,
|
|
metadata_threshold: Option<i64>,
|
|
data: Option<String>, // Data fromdirect
|
|
}
|
|
impl FcpRequest for ClientPut {
|
|
fn convert(&self) -> String {
|
|
let content_type = to_fcp_unwrap("ContentType=", &self.content_type, "\n");
|
|
let identifier = format!("Identifier={}\n", &self.identifier);
|
|
let verbosity = to_fcp_unwrap("Verbosity=", &self.verbosity, "\n");
|
|
let max_retries = to_fcp_unwrap("MaxRetries=", &self.max_retries, "\n");
|
|
let priority_class = to_fcp_unwrap("PriorityClass=", &self.priority_class, "\n");
|
|
let get_chk_only = to_fcp_unwrap("GetCHKOnly=", &self.get_chk_only, "\n");
|
|
let global = to_fcp_unwrap("Global=", &self.global, "\n");
|
|
let dont_compress = to_fcp_unwrap("DontCompress=", &self.dont_compress, "\n");
|
|
let codecs = to_fcp_unwrap("Codecs=", &self.codecs, "\n");
|
|
let client_token = to_fcp_unwrap("ClientToken=", &self.client_token, "\n");
|
|
let persistence = to_fcp_unwrap("Persistence=", &self.persistence, "\n");
|
|
let target_filename = to_fcp_unwrap("TargetFilename=", &self.target_filename, "\n");
|
|
let filename = to_fcp_unwrap("Filename=", &self.filename, "\n");
|
|
let early_encode = to_fcp_unwrap("EarlyEncode=", &self.early_encode, "\n");
|
|
let upload_from = to_fcp_unwrap("UploadFrom=", &self.upload_from, "\n");
|
|
let target_uri = to_fcp_unwrap("TargetURI=", &self.target_uri, "\n");
|
|
let file_hash = to_fcp_unwrap("FileHash=", &self.file_hash, "\n");
|
|
let binary_blob = to_fcp_unwrap("=", &self.binary_blob, "\n");
|
|
let fork_on_cacheable = to_fcp_unwrap("=", &self.fork_on_cacheable, "\n");
|
|
let extra_inserts_single_block = to_fcp_unwrap("=", &self.extra_inserts_single_block, "\n");
|
|
let extra_inserts_splitfile_header_block =
|
|
to_fcp_unwrap("=", &self.extra_inserts_splitfile_header_block, "\n");
|
|
let compatibility_mode = to_fcp_unwrap("=", &self.compatibility_mode, "\n");
|
|
let local_request_only = to_fcp_unwrap("LocalRequestOnly=", &self.local_request_only, "\n");
|
|
let override_splitfile_crypto_key =
|
|
to_fcp_unwrap("=", &self.override_splitfile_crypto_key, "\n");
|
|
let real_time_flag = to_fcp_unwrap("=", &self.real_time_flag, "\n");
|
|
let metadata_threshold = to_fcp_unwrap("=", &self.metadata_threshold, "\n");
|
|
let data = to_fcp_unwrap("", &self.data, "\n");
|
|
|
|
format!(
|
|
"ClientPut\n\
|
|
{}\
|
|
{}\
|
|
{}\
|
|
{}\
|
|
{}\
|
|
{}\
|
|
{}\
|
|
{}\
|
|
{}\
|
|
{}\
|
|
{}\
|
|
{}\
|
|
{}\
|
|
{}\
|
|
{}\
|
|
{}\
|
|
{}\
|
|
{}\
|
|
{}\
|
|
{}\
|
|
{}\
|
|
{}\
|
|
{}\
|
|
{}\
|
|
{}\
|
|
{}\
|
|
{}\
|
|
{}\
|
|
EndMessage\n\
|
|
{}\
|
|
",
|
|
format!("URI={}\n", self.uri.convert()),
|
|
format!("DataLength={}\n", self.data_length),
|
|
filename,
|
|
content_type,
|
|
identifier,
|
|
verbosity,
|
|
max_retries,
|
|
priority_class,
|
|
get_chk_only,
|
|
global,
|
|
dont_compress,
|
|
codecs,
|
|
client_token,
|
|
persistence,
|
|
target_filename,
|
|
early_encode,
|
|
upload_from,
|
|
target_uri,
|
|
file_hash,
|
|
binary_blob,
|
|
fork_on_cacheable,
|
|
extra_inserts_single_block,
|
|
extra_inserts_splitfile_header_block,
|
|
compatibility_mode,
|
|
local_request_only,
|
|
override_splitfile_crypto_key,
|
|
real_time_flag,
|
|
metadata_threshold,
|
|
data,
|
|
// to_fcp_unwrap("Verbosity", self.verbosity, "\n"),
|
|
)
|
|
}
|
|
}
|
|
|
|
impl ClientPut {
|
|
pub fn new_default_direct(uri: USK, identifier: &str, data: &str) -> ClientPut {
|
|
ClientPut {
|
|
uri: uri,
|
|
data_length: data.len(),
|
|
filename: None,
|
|
identifier: identifier.to_string(),
|
|
content_type: Some("text/json".to_string()),
|
|
verbosity: Some(VerbosityPut::SimpleProgress),
|
|
max_retries: Some(Retry::Num(50)),
|
|
priority_class: None,
|
|
get_chk_only: None,
|
|
global: None,
|
|
dont_compress: None,
|
|
codecs: None,
|
|
client_token: None,
|
|
persistence: None,
|
|
target_filename: None,
|
|
early_encode: None,
|
|
upload_from: None,
|
|
target_uri: None,
|
|
file_hash: None,
|
|
binary_blob: None,
|
|
fork_on_cacheable: None,
|
|
extra_inserts_single_block: None,
|
|
extra_inserts_splitfile_header_block: None,
|
|
compatibility_mode: None,
|
|
local_request_only: None,
|
|
override_splitfile_crypto_key: None,
|
|
real_time_flag: None,
|
|
metadata_threshold: None,
|
|
data: Some(data.to_string()),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn is_client_put_converting() {
|
|
let fin = "ClientPut\n\
|
|
URI=SSK@BnHXXv3Fa43w~~iz1tNUd~cj4OpUuDjVouOWZ5XlpX0,AwUSJG5ZS-FDZTqnt6skTzhxQe08T-fbKXj8aEHZsXM,AQABAAE\n\
|
|
DataLength=8\n\
|
|
ContentType=text/json\n\
|
|
Identifier=myidentifier\n\
|
|
Verbosity=0\n\
|
|
MaxRetries=50\n\
|
|
EndMessage\n\
|
|
Hey jude\n";
|
|
let input = ClientPut::new_default_direct(
|
|
USK{
|
|
ssk: SSK{
|
|
sign_key: "BnHXXv3Fa43w~~iz1tNUd~cj4OpUuDjVouOWZ5XlpX0".to_string(),
|
|
decrypt_key: "AwUSJG5ZS-FDZTqnt6skTzhxQe08T-fbKXj8aEHZsXM".to_string(),
|
|
settings: Some("AQABAAE".to_string()),
|
|
},
|
|
path: "myidentifier".to_string()
|
|
|
|
},
|
|
"myidentifier",
|
|
"Hey jude",
|
|
);
|
|
assert_eq!(fin, input.convert());
|
|
}
|
|
|
|
pub struct ClientGet {
|
|
ignore_ds: Option<bool>,
|
|
ds_only: Option<bool>,
|
|
uri: String, //FIXME freenet uri type
|
|
identifier: String,
|
|
verbosity: Option<VerbosityGet>,
|
|
max_size: Option<u32>,
|
|
max_temp_size: Option<u32>,
|
|
max_retries: Option<NumOrNone>,
|
|
priority_class: Option<Priority>,
|
|
persistence: Option<Persistence>,
|
|
client_token: Option<String>,
|
|
global: Option<bool>,
|
|
return_type: Option<ReturnType>,
|
|
binary_blob: Option<bool>,
|
|
filter_data: Option<bool>,
|
|
allowed_mime_types: Option<Vec<String>>,
|
|
filename: Option<Box<Path>>,
|
|
temp_filename: Option<Box<Path>>,
|
|
real_time_flag: Option<bool>,
|
|
initial_metadata_data_length: Option<u64>,
|
|
}
|
|
|
|
/*
|
|
ClientGet
|
|
IgnoreDS=false
|
|
DSOnly=false
|
|
URI=KSK@sample.txt
|
|
Identifier=Request Number One
|
|
Verbosity=0
|
|
ReturnType=direct
|
|
MaxSize=100
|
|
MaxTempSize=1000
|
|
MaxRetries=100
|
|
PriorityClass=1
|
|
Persistence=reboot
|
|
ClientToken=hello
|
|
Global=false
|
|
BinaryBlob=false
|
|
FilterData=true
|
|
EndMessage
|
|
*/
|
|
|
|
impl ClientGet {
|
|
pub fn new_default(uri: KEY, identifier: &str, return_type: ReturnType) -> ClientGet {
|
|
ClientGet {
|
|
ignore_ds: None,
|
|
ds_only: None,
|
|
uri: uri.convert(), //FIXME freenet uri type
|
|
identifier: identifier.to_string(),
|
|
verbosity: None,
|
|
max_size: None,
|
|
max_temp_size: None,
|
|
max_retries: None,
|
|
priority_class: None,
|
|
persistence: None,
|
|
client_token: None,
|
|
global: None,
|
|
return_type: Some(return_type),
|
|
binary_blob: None,
|
|
filter_data: None,
|
|
allowed_mime_types: None,
|
|
filename: None,
|
|
temp_filename: None,
|
|
real_time_flag: None,
|
|
initial_metadata_data_length: None,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl FcpRequest for ClientGet {
|
|
fn convert(&self) -> String {
|
|
format!(
|
|
"ClientGet\n\
|
|
{}\
|
|
{}\
|
|
{}\
|
|
{}\
|
|
{}\
|
|
{}\
|
|
{}\
|
|
{}\
|
|
{}\
|
|
{}\
|
|
{}\
|
|
{}\
|
|
{}\
|
|
{}\
|
|
{}\
|
|
{}\
|
|
{}\
|
|
{}\
|
|
{}\
|
|
EndMessage\n\n",
|
|
to_fcp_unwrap("IgnoreDS=", &self.ignore_ds, "\n"),
|
|
to_fcp_unwrap("DSonly=", &self.ds_only, "\n"),
|
|
format!("URI={}\n", &self.uri),
|
|
format!("Identifier={}\n", &self.identifier),
|
|
to_fcp_unwrap("Verbosity=", &self.verbosity, "\n"),
|
|
to_fcp_unwrap("ReturnType=", &self.return_type, "\n"),
|
|
to_fcp_unwrap("MaxSize=", &self.max_size, "\n"),
|
|
to_fcp_unwrap("MaxTempSize=", &self.max_temp_size, "\n"),
|
|
to_fcp_unwrap("MaxRetries=", &self.max_retries, "\n"),
|
|
to_fcp_unwrap("PriorityClass=", &self.priority_class, "\n"),
|
|
to_fcp_unwrap("Persistence=", &self.persistence, "\n"),
|
|
to_fcp_unwrap("ClientToken=", &self.client_token, "\n"),
|
|
to_fcp_unwrap("Global=", &self.global, "\n"),
|
|
to_fcp_unwrap("BinaryBlob=", &self.binary_blob, "\n"),
|
|
to_fcp_unwrap("FilterData=", &self.filter_data, "\n"),
|
|
to_fcp_unwrap("AllowedMIMETypes =", &self.allowed_mime_types, "\n"),
|
|
to_fcp_unwrap("Filename=", &self.filename, "\n"),
|
|
to_fcp_unwrap("RealTimeFlag=", &self.real_time_flag, "\n"),
|
|
to_fcp_unwrap(
|
|
"InitialMetadata.DataLength=",
|
|
&self.initial_metadata_data_length,
|
|
"\n"
|
|
),
|
|
)
|
|
}
|
|
}
|
|
|
|
pub struct Disconnect {
|
|
message_name: String,
|
|
}
|
|
|
|
pub struct Shutdown {
|
|
message_name: String,
|
|
}
|