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
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
|
use chrono::Utc;
use serde::{Deserialize, Serialize};
use std::borrow::Cow;
#[derive(Debug, Serialize, Deserialize)]
pub struct UserResponse {
pub username: String,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct RegisterRequest {
pub email: String,
pub username: String,
pub password: String,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct RegisterResponse {
pub session: String,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct DeleteUserResponse {}
#[derive(Debug, Serialize, Deserialize)]
pub struct LoginRequest {
pub username: String,
pub password: String,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct LoginResponse {
pub session: String,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct AddHistoryRequest {
pub id: String,
pub timestamp: chrono::DateTime<Utc>,
pub data: String,
pub hostname: String,
pub encryption: Option<EncryptionScheme>,
}
#[derive(Debug, Clone)]
pub enum EncryptionScheme {
/// Encryption scheme using xsalsa20poly1305 (tweetnacl crypto_box) using the legacy system
/// with no additional data and the same key for each entry with random IV
Legacy,
/// Following the PasetoV4 Specification for encryption:
/// <https://github.com/paseto-standard/paseto-spec/blob/master/docs/01-Protocol-Versions/Version4.md>
PasetoV4,
Unknown(String),
}
impl EncryptionScheme {
pub fn to_str(&self) -> &str {
match self {
EncryptionScheme::Legacy => "Legacy",
EncryptionScheme::PasetoV4 => "PasetoV4",
EncryptionScheme::Unknown(x) => x,
}
}
pub fn from_string(s: String) -> Self {
match &*s {
"Legacy" => EncryptionScheme::Legacy,
"PasetoV4" => EncryptionScheme::PasetoV4,
_ => EncryptionScheme::Unknown(s),
}
}
}
impl Serialize for EncryptionScheme {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
self.to_str().serialize(serializer)
}
}
impl<'de> Deserialize<'de> for EncryptionScheme {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
let s = String::deserialize(deserializer)?;
Ok(Self::from_string(s))
}
}
#[derive(Debug, Serialize, Deserialize)]
pub struct CountResponse {
pub count: i64,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct SyncHistoryRequest {
pub sync_ts: chrono::DateTime<chrono::FixedOffset>,
pub history_ts: chrono::DateTime<chrono::FixedOffset>,
pub host: String,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct SyncHistoryResponse {
/// deprecated
pub history: Vec<String>,
pub sync_history: Vec<SyncHistoryItem>,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct SyncHistoryItem {
pub id: String,
pub data: String,
pub encryption: Option<EncryptionScheme>,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct ErrorResponse<'a> {
pub reason: Cow<'a, str>,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct IndexResponse {
pub homage: String,
pub version: String,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct StatusResponse {
pub count: i64,
pub username: String,
pub deleted: Vec<String>,
// These could/should also go on the index of the server
// However, we do not request the server index as a part of normal sync
// I'd rather slightly increase the size of this response, than add an extra HTTP request
pub page_size: i64, // max page size supported by the server
pub version: String,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct DeleteHistoryRequest {
pub client_id: String,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct MessageResponse {
pub message: String,
}
|
