Compare commits

...
Author SHA1 Message Date
nvrl e15e1dcc76 refactor(core): sign in through proton_auth_rs::session
The sign-in steps are now the sequence Proton Gallery and Proton Stream
share. The stored session, the lock/unlock choice for two-password
accounts, the three mailbox-password tries and the errors front-ends
word themselves are unchanged. An account whose only second factor is
a security key now gets a clear message instead of a code prompt that
could only fail.
2026-11-20 15:43:31 +01:00
nvrl 734e9040fb Merge pull request #111 from narrrl/refactor/proton-media-rs
refactor(fuse): block fetch single flight from proton-media-rs
2026-11-20 13:28:42 +01:00
nvrl 01e3860741 refactor(fuse): block fetch single flight from proton-media-rs
BlockFlight is now proton_media_rs::SingleFlight joined with the typed
block result. Same semantics: one fetch per block, the key retires
before the result is published, and a waiter whose leader is cancelled
fetches the block itself.
2026-11-20 13:27:59 +01:00
nvrl 7a65e7011f Merge pull request #110 from narrrl/refactor/proton-base-rs
refactor(core): atomic file writes from proton-base-rs
2026-11-20 12:51:09 +01:00
nvrl 233d9e9e51 refactor(core): atomic file writes from proton-base-rs
Config, machine id and mount-failure files go through
proton_base_rs::atomic. Same modes as before (config 0600, the others
0644); the mount-failure file is now synced before its rename.
2026-11-20 12:16:32 +01:00
nvrl 73c4e1f6bf Merge pull request #107 from narrrl/refactor/proton-rs
refactor(photos): take the Gallery engine from crates.io
2026-11-20 12:10:34 +01:00
nvrl 26272cda6c refactor(core): take the keyring store from proton-auth-rs
The Secret Service connection that reconnects after the provider
restarts (B285) and the item replacement that oo7 before 0.7.0 needs
(B291) moved to proton-auth-rs, shared with Proton Gallery and Proton
Stream. pdfs-core keeps one KeyringStore per process; the session format,
service and user are unchanged. The two secretservice tests moved with
the code.
2026-11-20 12:01:50 +01:00
nvrl 370abd58dc refactor(photos): use the shared photo logic from proton-gallery-rs
RAW+JPEG grouping, Takeout reading, EXIF capture times, look-alike
hashes and the offline town lookup now come from proton-gallery-rs
0.1.1, shared with Proton Gallery. PhotoKind::classify delegates to the
shared MediaClass; the extension lists live there. No behaviour change.
2026-11-20 04:16:52 +01:00
nvrl 24594b24ae refactor(photos): take the Gallery engine from crates.io
Replace the git revision pin on Proton Gallery with proton-gallery-rs and
proton-gallery-app-rs 0.1.0 from the proton-rs workspace. This also moves
the engine from 858d244 to b171232. The Nix package no longer needs to
fetch from Git.
2026-11-20 02:44:22 +01:00
nvrl 04f0713012 Merge pull request #106 from narrrl/feat/shared-gallery
feat(photos): release Proton Drive 3.9.0
2026-11-19 21:31:16 +01:00
37 changed files with 387 additions and 34934 deletions

No files matched your search

Generated
+139 -66
View File
@@ -182,6 +182,17 @@ version = "1.0.104"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "330a5ed07fa54e4702c9d6c4174f74427fc0ef6e214bbd677ae50a5099946470"
[[package]]
name = "apple-native-keyring-store"
version = "1.0.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2b350bfd03649e07aa05c0a81b3e15934374e585c98204a57e20b9d49f49bb9a"
dependencies = [
"keyring-core",
"log",
"security-framework",
]
[[package]]
name = "arbitrary"
version = "1.5.0"
@@ -3618,23 +3629,23 @@ dependencies = [
"dbus-secret-service-keyring-store",
"directories",
"ignore",
"kamadak-exif",
"keyring-core",
"libc",
"parking_lot 0.13.0",
"proton-auth-rs",
"proton-base-rs",
"proton-drive-rs",
"proton-gallery-rs",
"proton-sdk",
"rusqlite",
"serde",
"serde_json",
"sha1 0.11.0",
"sha2 0.11.1",
"shell-words",
"thiserror 2.0.21",
"tokio",
"tracing",
"zeroize",
"zip",
]
[[package]]
@@ -3655,9 +3666,10 @@ dependencies = [
"notify",
"parking_lot 0.13.0",
"pdfs-core",
"pg-app",
"pg-core",
"proton-drive-rs",
"proton-gallery-app-rs",
"proton-gallery-rs",
"proton-media-rs",
"rustix",
"serde",
"serde_json",
@@ -3683,7 +3695,7 @@ dependencies = [
"libadwaita",
"pangocairo",
"pdfs-core",
"pg-core",
"proton-gallery-rs",
"reqwest",
"serde",
"serde_json",
@@ -3708,65 +3720,6 @@ version = "2.3.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220"
[[package]]
name = "pg-app"
version = "0.3.0"
source = "git+https://github.com/narrrl/proton-gallery.git?rev=858d2446f71214ec5357eb8b543d6b82abf47386#858d2446f71214ec5357eb8b543d6b82abf47386"
dependencies = [
"async-trait",
"hex",
"pg-core",
"pg-drive",
"proton-drive-rs",
"proton-sdk",
"serde_json",
"sha2 0.11.1",
"tempfile",
"thiserror 2.0.21",
"tokio",
"tracing",
"zeroize",
]
[[package]]
name = "pg-core"
version = "0.3.0"
source = "git+https://github.com/narrrl/proton-gallery.git?rev=858d2446f71214ec5357eb8b543d6b82abf47386#858d2446f71214ec5357eb8b543d6b82abf47386"
dependencies = [
"aes-gcm 0.11.1",
"async-trait",
"getrandom 0.4.3",
"hex",
"rusqlite",
"serde",
"serde_json",
"sha2 0.11.1",
"tempfile",
"thiserror 2.0.21",
"tokio",
"tokio-util",
"zeroize",
]
[[package]]
name = "pg-drive"
version = "0.3.0"
source = "git+https://github.com/narrrl/proton-gallery.git?rev=858d2446f71214ec5357eb8b543d6b82abf47386#858d2446f71214ec5357eb8b543d6b82abf47386"
dependencies = [
"async-trait",
"hex",
"pg-core",
"proton-drive-rs",
"proton-sdk",
"serde",
"serde_json",
"sha2 0.11.1",
"thiserror 2.0.21",
"tokio",
"tracing",
"zeroize",
]
[[package]]
name = "pgp"
version = "0.21.0"
@@ -3971,6 +3924,34 @@ dependencies = [
"syn 2.0.119",
]
[[package]]
name = "proton-auth-rs"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "383119b502a1741f1ec4a248cb1e8d2f4835d5ea415803b041f76b6f89cf1ffc"
dependencies = [
"apple-native-keyring-store",
"dbus-secret-service",
"dbus-secret-service-keyring-store",
"keyring-core",
"proton-sdk",
"serde_json",
"thiserror 2.0.21",
"tracing",
"windows-native-keyring-store",
"zeroize",
]
[[package]]
name = "proton-base-rs"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "451151bb1025ea5cb362f69e2bfb2d45afed603e5c6daa3dc752333a7c29c878"
dependencies = [
"rusqlite",
"thiserror 2.0.21",
]
[[package]]
name = "proton-drive-rs"
version = "0.12.1"
@@ -3999,6 +3980,85 @@ dependencies = [
"tracing",
]
[[package]]
name = "proton-gallery-app-rs"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d6d18d11266ab2be5ab2f4b4040941caf2736c257e13909af7be8ea331892d59"
dependencies = [
"async-trait",
"futures-util",
"hex",
"proton-drive-rs",
"proton-gallery-drive-rs",
"proton-gallery-rs",
"proton-sdk",
"serde_json",
"sha2 0.11.1",
"tempfile",
"thiserror 2.0.21",
"tokio",
"tracing",
"zeroize",
]
[[package]]
name = "proton-gallery-drive-rs"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "535a14f63fd542701d2606acb971d4a7e8f235ca7b9439fea8c80a3f26110186"
dependencies = [
"async-trait",
"hex",
"proton-drive-rs",
"proton-gallery-rs",
"proton-sdk",
"serde",
"serde_json",
"sha2 0.11.1",
"thiserror 2.0.21",
"tokio",
"tracing",
"zeroize",
]
[[package]]
name = "proton-gallery-rs"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "dc9c9bbb76a5fba4071ee90de4aada71c292c0e408024ddfb04a12869291404a"
dependencies = [
"aes-gcm 0.11.1",
"async-trait",
"getrandom 0.4.3",
"hex",
"kamadak-exif",
"rusqlite",
"serde",
"serde_json",
"sha2 0.11.1",
"tempfile",
"thiserror 2.0.21",
"tokio",
"tokio-util",
"tracing",
"zeroize",
"zip",
]
[[package]]
name = "proton-media-rs"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f03aa6c403e4f2f7a8f9a444dff1e268d8bc9bcaf1d0d953cc3a1312d798f1ef"
dependencies = [
"lru",
"sha2 0.11.1",
"thiserror 2.0.21",
"tokio",
"tracing",
]
[[package]]
name = "proton-sdk"
version = "0.12.1"
@@ -5139,7 +5199,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "32497e9a4c7b38532efcdebeef879707aa9f794296a4f0244f6f69e9bc8574bd"
dependencies = [
"fastrand",
"getrandom 0.3.4",
"getrandom 0.4.3",
"once_cell",
"rustix",
"windows-sys 0.61.2",
@@ -5857,6 +5917,19 @@ version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
[[package]]
name = "windows-native-keyring-store"
version = "1.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "063426e76fdec7438d56bb777f67e318a84a25c707b07e575cb8b78e10c028f8"
dependencies = [
"byteorder",
"keyring-core",
"regex",
"windows-sys 0.61.2",
"zeroize",
]
[[package]]
name = "windows-result"
version = "0.4.1"
+7 -2
View File
@@ -17,8 +17,8 @@ categories = ["filesystem", "command-line-utilities"]
[workspace.dependencies]
proton-sdk = { version = "0.12.1" }
proton-drive-rs = { version = "0.12.1" }
pg-app = { git = "https://github.com/narrrl/proton-gallery.git", rev = "858d2446f71214ec5357eb8b543d6b82abf47386" }
pg-core = { git = "https://github.com/narrrl/proton-gallery.git", rev = "858d2446f71214ec5357eb8b543d6b82abf47386" }
proton-gallery-app-rs = "0.1.0"
proton-gallery-rs = "0.1.1"
chrono = { version = "0.4", default-features = false, features = ["std"] }
# Internal crates.
@@ -63,6 +63,11 @@ rusqlite = { version = "0.41", features = ["bundled"] }
# Secret Service store is the one keyring 3's `sync-secret-service` wrapped, and
# with no `target` it matches items v3 wrote, so existing logins survive.
keyring-core = "1"
# The keyring store all three apps share: reconnects after a Secret Service
# restart (B285) and replaces items instead of editing them (B291).
proton-auth-rs = "0.1.1"
proton-base-rs = "0.1"
proton-media-rs = "0.1.1"
dbus-secret-service-keyring-store = { version = "1", features = ["crypto-rust"] }
# The same Secret Service client the store wraps, used directly to replace an
# item instead of editing it, which oo7 before 0.7.0 kept only in memory (B291).
+3 -3
View File
@@ -12,6 +12,7 @@ description = "Core auth/session/config for the Proton Drive Linux client"
[dependencies]
proton-sdk.workspace = true
proton-drive-rs.workspace = true
proton-gallery-rs.workspace = true
chrono.workspace = true
tokio.workspace = true
serde.workspace = true
@@ -22,10 +23,10 @@ directories.workspace = true
ignore.workspace = true
shell-words.workspace = true
sha2.workspace = true
sha1.workspace = true
zip.workspace = true
rusqlite.workspace = true
keyring-core.workspace = true
proton-auth-rs = { workspace = true, features = ["keyring", "session"] }
proton-base-rs.workspace = true
dbus-secret-service-keyring-store.workspace = true
dbus-secret-service.workspace = true
parking_lot.workspace = true
@@ -33,4 +34,3 @@ async-trait.workspace = true
libc.workspace = true
zeroize.workspace = true
base64.workspace = true
exif = { version = "0.6", package = "kamadak-exif" }
File diff suppressed because it is too large. Load diff
-250
View File
@@ -1,250 +0,0 @@
AD Andorra
AE United Arab Emirates
AF Afghanistan
AG Antigua and Barbuda
AI Anguilla
AL Albania
AM Armenia
AO Angola
AQ Antarctica
AR Argentina
AS American Samoa
AT Austria
AU Australia
AW Aruba
AX Åland Islands
AZ Azerbaijan
BA Bosnia and Herzegovina
BB Barbados
BD Bangladesh
BE Belgium
BF Burkina Faso
BG Bulgaria
BH Bahrain
BI Burundi
BJ Benin
BL Saint Barthélemy
BM Bermuda
BN Brunei Darussalam
BO Bolivia, Plurinational State of
BQ Bonaire, Sint Eustatius and Saba
BR Brazil
BS Bahamas
BT Bhutan
BV Bouvet Island
BW Botswana
BY Belarus
BZ Belize
CA Canada
CC Cocos (Keeling) Islands
CD Congo, The Democratic Republic of the
CF Central African Republic
CG Congo
CH Switzerland
CI Côte d'Ivoire
CK Cook Islands
CL Chile
CM Cameroon
CN China
CO Colombia
CR Costa Rica
CU Cuba
CV Cabo Verde
CW Curaçao
CX Christmas Island
CY Cyprus
CZ Czechia
DE Germany
DJ Djibouti
DK Denmark
DM Dominica
DO Dominican Republic
DZ Algeria
EC Ecuador
EE Estonia
EG Egypt
EH Western Sahara
ER Eritrea
ES Spain
ET Ethiopia
FI Finland
FJ Fiji
FK Falkland Islands (Malvinas)
FM Micronesia, Federated States of
FO Faroe Islands
FR France
GA Gabon
GB United Kingdom
GD Grenada
GE Georgia
GF French Guiana
GG Guernsey
GH Ghana
GI Gibraltar
GL Greenland
GM Gambia
GN Guinea
GP Guadeloupe
GQ Equatorial Guinea
GR Greece
GS South Georgia and the South Sandwich Islands
GT Guatemala
GU Guam
GW Guinea-Bissau
GY Guyana
HK Hong Kong
HM Heard Island and McDonald Islands
HN Honduras
HR Croatia
HT Haiti
HU Hungary
ID Indonesia
IE Ireland
IL Israel
IM Isle of Man
IN India
IO British Indian Ocean Territory
IQ Iraq
IR Iran, Islamic Republic of
IS Iceland
IT Italy
JE Jersey
JM Jamaica
JO Jordan
JP Japan
KE Kenya
KG Kyrgyzstan
KH Cambodia
KI Kiribati
KM Comoros
KN Saint Kitts and Nevis
KP Korea, Democratic People's Republic of
KR Korea, Republic of
KW Kuwait
KY Cayman Islands
KZ Kazakhstan
LA Lao People's Democratic Republic
LB Lebanon
LC Saint Lucia
LI Liechtenstein
LK Sri Lanka
LR Liberia
LS Lesotho
LT Lithuania
LU Luxembourg
LV Latvia
LY Libya
MA Morocco
MC Monaco
MD Moldova, Republic of
ME Montenegro
MF Saint Martin (French part)
MG Madagascar
MH Marshall Islands
MK North Macedonia
ML Mali
MM Myanmar
MN Mongolia
MO Macao
MP Northern Mariana Islands
MQ Martinique
MR Mauritania
MS Montserrat
MT Malta
MU Mauritius
MV Maldives
MW Malawi
MX Mexico
MY Malaysia
MZ Mozambique
NA Namibia
NC New Caledonia
NE Niger
NF Norfolk Island
NG Nigeria
NI Nicaragua
NL Netherlands
NO Norway
NP Nepal
NR Nauru
NU Niue
NZ New Zealand
OM Oman
PA Panama
PE Peru
PF French Polynesia
PG Papua New Guinea
PH Philippines
PK Pakistan
PL Poland
PM Saint Pierre and Miquelon
PN Pitcairn
PR Puerto Rico
PS Palestine, State of
PT Portugal
PW Palau
PY Paraguay
QA Qatar
RE Réunion
RO Romania
RS Serbia
RU Russian Federation
RW Rwanda
SA Saudi Arabia
SB Solomon Islands
SC Seychelles
SD Sudan
SE Sweden
SG Singapore
SH Saint Helena, Ascension and Tristan da Cunha
SI Slovenia
SJ Svalbard and Jan Mayen
SK Slovakia
SL Sierra Leone
SM San Marino
SN Senegal
SO Somalia
SR Suriname
SS South Sudan
ST Sao Tome and Principe
SV El Salvador
SX Sint Maarten (Dutch part)
SY Syrian Arab Republic
SZ Eswatini
TC Turks and Caicos Islands
TD Chad
TF French Southern Territories
TG Togo
TH Thailand
TJ Tajikistan
TK Tokelau
TL Timor-Leste
TM Turkmenistan
TN Tunisia
TO Tonga
TR Türkiye
TT Trinidad and Tobago
TV Tuvalu
TW Taiwan, Province of China
TZ Tanzania, United Republic of
UA Ukraine
UG Uganda
UM United States Minor Outlying Islands
US United States
UY Uruguay
UZ Uzbekistan
VA Holy See (Vatican City State)
VC Saint Vincent and the Grenadines
VE Venezuela, Bolivarian Republic of
VG Virgin Islands, British
VI Virgin Islands, U.S.
VN Viet Nam
VU Vanuatu
WF Wallis and Futuna
WS Samoa
XK Kosovo
YE Yemen
YT Mayotte
ZA South Africa
ZM Zambia
ZW Zimbabwe
1 AD Andorra
2 AE United Arab Emirates
3 AF Afghanistan
4 AG Antigua and Barbuda
5 AI Anguilla
6 AL Albania
7 AM Armenia
8 AO Angola
9 AQ Antarctica
10 AR Argentina
11 AS American Samoa
12 AT Austria
13 AU Australia
14 AW Aruba
15 AX Åland Islands
16 AZ Azerbaijan
17 BA Bosnia and Herzegovina
18 BB Barbados
19 BD Bangladesh
20 BE Belgium
21 BF Burkina Faso
22 BG Bulgaria
23 BH Bahrain
24 BI Burundi
25 BJ Benin
26 BL Saint Barthélemy
27 BM Bermuda
28 BN Brunei Darussalam
29 BO Bolivia, Plurinational State of
30 BQ Bonaire, Sint Eustatius and Saba
31 BR Brazil
32 BS Bahamas
33 BT Bhutan
34 BV Bouvet Island
35 BW Botswana
36 BY Belarus
37 BZ Belize
38 CA Canada
39 CC Cocos (Keeling) Islands
40 CD Congo, The Democratic Republic of the
41 CF Central African Republic
42 CG Congo
43 CH Switzerland
44 CI Côte d'Ivoire
45 CK Cook Islands
46 CL Chile
47 CM Cameroon
48 CN China
49 CO Colombia
50 CR Costa Rica
51 CU Cuba
52 CV Cabo Verde
53 CW Curaçao
54 CX Christmas Island
55 CY Cyprus
56 CZ Czechia
57 DE Germany
58 DJ Djibouti
59 DK Denmark
60 DM Dominica
61 DO Dominican Republic
62 DZ Algeria
63 EC Ecuador
64 EE Estonia
65 EG Egypt
66 EH Western Sahara
67 ER Eritrea
68 ES Spain
69 ET Ethiopia
70 FI Finland
71 FJ Fiji
72 FK Falkland Islands (Malvinas)
73 FM Micronesia, Federated States of
74 FO Faroe Islands
75 FR France
76 GA Gabon
77 GB United Kingdom
78 GD Grenada
79 GE Georgia
80 GF French Guiana
81 GG Guernsey
82 GH Ghana
83 GI Gibraltar
84 GL Greenland
85 GM Gambia
86 GN Guinea
87 GP Guadeloupe
88 GQ Equatorial Guinea
89 GR Greece
90 GS South Georgia and the South Sandwich Islands
91 GT Guatemala
92 GU Guam
93 GW Guinea-Bissau
94 GY Guyana
95 HK Hong Kong
96 HM Heard Island and McDonald Islands
97 HN Honduras
98 HR Croatia
99 HT Haiti
100 HU Hungary
101 ID Indonesia
102 IE Ireland
103 IL Israel
104 IM Isle of Man
105 IN India
106 IO British Indian Ocean Territory
107 IQ Iraq
108 IR Iran, Islamic Republic of
109 IS Iceland
110 IT Italy
111 JE Jersey
112 JM Jamaica
113 JO Jordan
114 JP Japan
115 KE Kenya
116 KG Kyrgyzstan
117 KH Cambodia
118 KI Kiribati
119 KM Comoros
120 KN Saint Kitts and Nevis
121 KP Korea, Democratic People's Republic of
122 KR Korea, Republic of
123 KW Kuwait
124 KY Cayman Islands
125 KZ Kazakhstan
126 LA Lao People's Democratic Republic
127 LB Lebanon
128 LC Saint Lucia
129 LI Liechtenstein
130 LK Sri Lanka
131 LR Liberia
132 LS Lesotho
133 LT Lithuania
134 LU Luxembourg
135 LV Latvia
136 LY Libya
137 MA Morocco
138 MC Monaco
139 MD Moldova, Republic of
140 ME Montenegro
141 MF Saint Martin (French part)
142 MG Madagascar
143 MH Marshall Islands
144 MK North Macedonia
145 ML Mali
146 MM Myanmar
147 MN Mongolia
148 MO Macao
149 MP Northern Mariana Islands
150 MQ Martinique
151 MR Mauritania
152 MS Montserrat
153 MT Malta
154 MU Mauritius
155 MV Maldives
156 MW Malawi
157 MX Mexico
158 MY Malaysia
159 MZ Mozambique
160 NA Namibia
161 NC New Caledonia
162 NE Niger
163 NF Norfolk Island
164 NG Nigeria
165 NI Nicaragua
166 NL Netherlands
167 NO Norway
168 NP Nepal
169 NR Nauru
170 NU Niue
171 NZ New Zealand
172 OM Oman
173 PA Panama
174 PE Peru
175 PF French Polynesia
176 PG Papua New Guinea
177 PH Philippines
178 PK Pakistan
179 PL Poland
180 PM Saint Pierre and Miquelon
181 PN Pitcairn
182 PR Puerto Rico
183 PS Palestine, State of
184 PT Portugal
185 PW Palau
186 PY Paraguay
187 QA Qatar
188 RE Réunion
189 RO Romania
190 RS Serbia
191 RU Russian Federation
192 RW Rwanda
193 SA Saudi Arabia
194 SB Solomon Islands
195 SC Seychelles
196 SD Sudan
197 SE Sweden
198 SG Singapore
199 SH Saint Helena, Ascension and Tristan da Cunha
200 SI Slovenia
201 SJ Svalbard and Jan Mayen
202 SK Slovakia
203 SL Sierra Leone
204 SM San Marino
205 SN Senegal
206 SO Somalia
207 SR Suriname
208 SS South Sudan
209 ST Sao Tome and Principe
210 SV El Salvador
211 SX Sint Maarten (Dutch part)
212 SY Syrian Arab Republic
213 SZ Eswatini
214 TC Turks and Caicos Islands
215 TD Chad
216 TF French Southern Territories
217 TG Togo
218 TH Thailand
219 TJ Tajikistan
220 TK Tokelau
221 TL Timor-Leste
222 TM Turkmenistan
223 TN Tunisia
224 TO Tonga
225 TR Türkiye
226 TT Trinidad and Tobago
227 TV Tuvalu
228 TW Taiwan, Province of China
229 TZ Tanzania, United Republic of
230 UA Ukraine
231 UG Uganda
232 UM United States Minor Outlying Islands
233 US United States
234 UY Uruguay
235 UZ Uzbekistan
236 VA Holy See (Vatican City State)
237 VC Saint Vincent and the Grenadines
238 VE Venezuela, Bolivarian Republic of
239 VG Virgin Islands, British
240 VI Virgin Islands, U.S.
241 VN Viet Nam
242 VU Vanuatu
243 WF Wallis and Futuna
244 WS Samoa
245 XK Kosovo
246 YE Yemen
247 YT Mayotte
248 ZA South Africa
249 ZM Zambia
250 ZW Zimbabwe
+107 -170
View File
@@ -28,6 +28,8 @@ use std::time::Duration;
use base64::Engine as _;
use base64::engine::general_purpose::STANDARD as BASE64;
use keyring_core::Entry;
use proton_auth_rs::session::{self, SignInError, Step};
use proton_auth_rs::{KeyringStore, SecretStore};
use proton_drive_rs::{KeySalt, ProtonDriveClient};
use proton_sdk::account::KeyPassphrases;
use proton_sdk::api::{HumanVerification, HumanVerificationCredential};
@@ -125,82 +127,28 @@ fn client_config() -> ProtonClientConfiguration {
/// Run `op` on the session's keyring entry.
fn with_keyring<T>(op: impl Fn(&Entry) -> keyring_core::Result<T>) -> Result<T> {
with_keyring_entry(KEYRING_SERVICE, KEYRING_USER, op)
Ok(keyring().with_entry(KEYRING_USER, op)?)
}
/// Run `op` on the entry `service`/`user`, reconnecting once if the Secret
/// Service fails the call.
/// The process's keyring, connected on first use.
///
/// The store holds one D-Bus connection and one Secret Service session for the
/// whole process. The session lives in the provider's memory: once the provider
/// restarts (oo7's unit restarts it on failure, and both oo7 and gnome-keyring
/// can be `--replace`d), every read and write on the old session fails with
/// `NoSession`, for as long as this process runs. A daemon then keeps refreshed
/// tokens only in memory, and a cold boot loses them (`docs/BUGS.md` B285). A
/// platform failure therefore drops the store, and the call is made once more
/// on a new one. A locked keyring, a dismissed prompt or a missing entry is
/// not the connection's fault and comes back as it is.
fn with_keyring_entry<T>(
service: &str,
user: &str,
op: impl Fn(&Entry) -> keyring_core::Result<T>,
) -> Result<T> {
let store = keyring_store()?;
match op(&Entry::new(service, user)?) {
Err(keyring_core::Error::PlatformFailure(e)) => {
tracing::warn!(
error = %e,
"the Secret Service failed this process's connection; reconnecting"
);
drop_keyring_store(&store);
keyring_store()?;
Ok(op(&Entry::new(service, user)?)?)
/// One connection for the whole process; when the Secret Service fails it
/// (a restarted provider forgets the session, `docs/BUGS.md` B285), the call
/// reconnects and is made once more. A changed session replaces its item
/// instead of editing it (B291). Both live in `proton-auth-rs`.
fn keyring() -> &'static KeyringStore {
static STORE: std::sync::OnceLock<KeyringStore> = std::sync::OnceLock::new();
STORE.get_or_init(|| {
#[cfg(not(test))]
{
KeyringStore::new(KEYRING_SERVICE)
}
result => Ok(result?),
}
}
/// Held while the default store is looked at and replaced, so that threads
/// failing at the same time drop the broken store once and share its
/// replacement.
static KEYRING_STORE: parking_lot::Mutex<()> = parking_lot::Mutex::new(());
/// The process's Secret Service store, connected now if there is none.
///
/// Connected lazily rather than once at startup so a session bus that was not
/// up yet on the first attempt is tried again on the next one.
fn keyring_store() -> Result<Arc<keyring_core::CredentialStore>> {
let _swap = KEYRING_STORE.lock();
if let Some(store) = keyring_core::get_default_store() {
return Ok(store);
}
let store = connect_keyring_store()?;
keyring_core::set_default_store(Arc::clone(&store));
Ok(store)
}
/// Forget `failed`, unless another thread has already replaced it.
fn drop_keyring_store(failed: &Arc<keyring_core::CredentialStore>) {
let _swap = KEYRING_STORE.lock();
if keyring_core::get_default_store().is_some_and(|store| Arc::ptr_eq(&store, failed)) {
keyring_core::unset_default_store();
}
}
#[cfg(not(test))]
fn connect_keyring_store() -> Result<Arc<keyring_core::CredentialStore>> {
Ok(dbus_secret_service_keyring_store::Store::new()?)
}
/// The tests' in-memory store when they set one, so a reconnect finds the
/// same entries; the real Secret Service otherwise.
#[cfg(test)]
fn connect_keyring_store() -> Result<Arc<keyring_core::CredentialStore>> {
tests::KEYRING_CONNECTS.fetch_add(1, Ordering::SeqCst);
match tests::MOCK_STORE.lock().clone() {
Some(store) => Ok(store),
None => Ok(dbus_secret_service_keyring_store::Store::new()?),
}
#[cfg(test)]
{
KeyringStore::with_connector(KEYRING_SERVICE, Arc::new(tests::connect_keyring_store))
.replace_items(|| tests::MOCK_STORE.lock().is_none())
}
})
}
/// What the user answered when asked for the mailbox password.
@@ -332,74 +280,58 @@ pub async fn login_verified(
get_totp: impl Fn() -> Result<String>,
get_mailbox: impl Fn(u32) -> Result<Mailbox>,
) -> Result<()> {
let password = Zeroizing::new(password.to_owned());
let session = ProtonApiSession::begin_verified(
client_config(),
username,
password.as_bytes(),
verification,
)
.await
.map_err(classify_verification_gate);
let mut session = session?;
if session.is_waiting_for_second_factor() {
let code = get_totp()?;
session.apply_second_factor_code(code.trim()).await?;
}
// Grab the key salts while this access token still has the `locked` scope:
// after its first refresh it never will again, and without them no later
// resume can unlock the key chain. See `StoredSession::key_salts`.
let key_salts = ProtonDriveClient::new(&session, Vec::new())
.account()
.key_salts()
.await?;
// A single-password account's mailbox password is the login password. A
// two-password one has a second secret the user must type, and it is checked
// against the account now — a typo found at login is a retry, found later it
// is a daemon that never mounts.
let (passphrases, remember) = match session.password_mode() {
PasswordMode::Single => (
derive_verified(&session, password.as_bytes(), key_salts.clone()).await?,
true,
),
PasswordMode::Dual => {
let mut attempt = 0;
loop {
let mailbox = get_mailbox(attempt)?;
match derive_verified(&session, mailbox.password.as_bytes(), key_salts.clone())
.await
{
Ok(passphrases) => break (passphrases, mailbox.remember),
Err(Error::WrongMailboxPassword) if attempt + 1 < MAILBOX_ATTEMPTS => {
attempt += 1;
}
Err(e) => return Err(e),
}
// The sequence is `proton_auth_rs::session`, shared with the other Proton
// apps. It reads the key salts before unlocking, while this access token
// still has the `locked` scope: after its first refresh it never will
// again, and without them no later resume can unlock the key chain. See
// `StoredSession::key_salts`.
let mut step = session::begin(client_config(), username, password, verification)
.await
.map_err(sign_in_error)?;
let (unlocked, remember) = loop {
step = match step {
Step::SecondFactor(pending) => {
let code = get_totp()?;
pending.second_factor(&code).await.map_err(sign_in_error)?
}
}
// A single-password account's mailbox password is the login password.
Step::Unlock(pending) => break (pending.unlock().await.map_err(sign_in_error)?, true),
// A two-password one has a second secret the user must type, and it is
// checked against the account now — a typo found at login is a retry,
// found later it is a daemon that never mounts.
Step::MailboxPassword(pending) => {
let mut attempt = 0;
break loop {
let mailbox = get_mailbox(attempt)?;
match pending.mailbox_password(&mailbox.password).await {
Ok(unlocked) => break (unlocked, mailbox.remember),
Err(SignInError::WrongMailboxPassword)
if attempt + 1 < MAILBOX_ATTEMPTS =>
{
attempt += 1;
}
Err(e) => return Err(sign_in_error(e)),
}
};
}
};
};
let tokens = session.current_tokens().await;
register_refresh_handler(&session, tokens.refresh_token.clone());
let tokens = unlocked.tokens().await;
register_refresh_handler(&unlocked.session, tokens.refresh_token.clone());
let stored = StoredSession {
session_id: session.session_id().as_str().to_owned(),
username: session.username().to_owned(),
user_id: session.user_id().as_str().to_owned(),
session_id: tokens.session_id,
username: tokens.username,
user_id: tokens.user_id,
access_token: tokens.access_token,
refresh_token: tokens.refresh_token,
scopes: session.scopes().to_vec(),
password_mode: match session.password_mode() {
PasswordMode::Single => 1,
PasswordMode::Dual => 2,
},
scopes: tokens.scopes,
password_mode: session::password_mode_to_wire(tokens.password_mode),
mailbox_password: String::new(),
key_salts,
key_salts: unlocked.key_salts,
key_passphrases: None,
};
keep_passphrases(stored, &passphrases, remember)
keep_passphrases(stored, &unlocked.key_passphrases, remember)
}
/// Derive the key passphrases from `mailbox` and prove they unlock the account.
@@ -473,52 +405,34 @@ fn decode_secret(secret: &[u8]) -> Option<KeyPassphrases> {
decode(&serde_json::from_slice(secret).ok()?)
}
/// Lift a human-verification gate out of the generic API error into the typed
/// variant a front-end can act on.
/// A failed sign-in step as this crate's error.
///
/// Only a gate that names a solvable method is converted. A `9001` with no
/// `Details`, or one offering only `email`/`sms`, stays a plain API error:
/// promoting it would send the UI to open a verification page it cannot
/// complete, which reads to the user as a hang rather than a refusal.
fn classify_verification_gate(e: ProtonError) -> Error {
let ProtonError::Api(api) = &e else {
return e.into();
};
match api.human_verification() {
Some(hv) if hv.supports_captcha() => Error::HumanVerificationRequired(Box::new(hv)),
_ => e.into(),
/// A blocked, refused or wrong-code attempt goes back to the Proton error it
/// came from, which is what the front-ends word themselves. Only a gate that
/// names a solvable method is a [`Error::HumanVerificationRequired`]: one that
/// offers only `email`/`sms` stays a plain API error, because sending the UI to
/// open a page it cannot complete reads as a hang rather than a refusal.
fn sign_in_error(e: SignInError) -> Error {
match e {
SignInError::HumanVerification(hv) => Error::HumanVerificationRequired(hv),
SignInError::SecurityKeyOnly => Error::SecurityKeyOnly,
SignInError::Blocked(api) | SignInError::Rejected(api) | SignInError::WrongCode(api) => {
Error::Proton(ProtonError::Api(api))
}
SignInError::WrongMailboxPassword => Error::WrongMailboxPassword,
SignInError::Proton(e) => e.into(),
other => Error::Other(other.to_string()),
}
}
/// Save `stored` to the keyring.
///
/// An existing entry is replaced by a new item rather than edited, because
/// oo7 before 0.7.0 keeps an edit only in memory and a reboot brings the
/// spent refresh token back (`docs/BUGS.md` B291). The usual write is the
/// fallback: for the first save, and whenever replacing is not possible.
/// Save the session. An existing entry is replaced by a new item rather than
/// edited, because oo7 before 0.7.0 keeps an edit only in memory and a reboot
/// brings the spent refresh token back (`docs/BUGS.md` B291).
fn write_stored(stored: &StoredSession) -> Result<()> {
let json = Zeroizing::new(serde_json::to_string(stored)?);
if replace_items() {
match crate::secretservice::replace(KEYRING_SERVICE, KEYRING_USER, json.as_bytes()) {
crate::secretservice::Replaced::Saved => return Ok(()),
crate::secretservice::Replaced::Skipped(why) => {
tracing::debug!(%why, "not replacing the keyring item; writing it in place");
}
}
}
with_keyring(|entry| entry.set_password(&json))
}
/// Whether [`write_stored`] talks to the Secret Service directly: always,
/// except in tests that use the in-memory store.
#[cfg(not(test))]
fn replace_items() -> bool {
true
}
#[cfg(test)]
fn replace_items() -> bool {
tests::MOCK_STORE.lock().is_none()
Ok(keyring().set(KEYRING_USER, &json)?)
}
/// A short, one-way tag for a refresh token, for the log: enough to tell
@@ -1324,9 +1238,30 @@ mod tests {
let store: Arc<keyring_core::CredentialStore> = keyring_core::mock::Store::new().unwrap();
*MOCK_STORE.lock() = Some(Arc::clone(&store));
keyring_core::set_default_store(store);
keyring().disconnect();
turn
}
/// The tests' in-memory store when they set one, so a reconnect finds the
/// same entries; the real Secret Service otherwise.
pub(super) fn connect_keyring_store() -> keyring_core::Result<Arc<keyring_core::CredentialStore>>
{
KEYRING_CONNECTS.fetch_add(1, Ordering::SeqCst);
match MOCK_STORE.lock().clone() {
Some(store) => Ok(store),
None => Ok(dbus_secret_service_keyring_store::Store::new()?),
}
}
/// Run `op` on the entry `service`/`user` of the real Secret Service.
fn with_keyring_entry<T>(
store: &KeyringStore,
user: &str,
op: impl Fn(&Entry) -> keyring_core::Result<T>,
) -> Result<T> {
Ok(store.with_entry(user, op)?)
}
static KEYRING: parking_lot::Mutex<()> = parking_lot::Mutex::new(());
/// The in-memory store a reconnect hands out, so it finds the same
@@ -1427,7 +1362,8 @@ mod tests {
let _turn = KEYRING.lock();
*MOCK_STORE.lock() = None;
keyring_core::unset_default_store();
let (service, user) = ("pdfs-test", "restart");
let user = "restart";
let service = &KeyringStore::with_connector("pdfs-test", Arc::new(connect_keyring_store));
with_keyring_entry(service, user, |e| e.set_password("before")).unwrap();
let status = std::process::Command::new("sh")
@@ -1468,6 +1404,7 @@ mod tests {
let _turn = KEYRING.lock();
*MOCK_STORE.lock() = None;
keyring_core::unset_default_store();
keyring().disconnect();
for refresh in ["r1", "r2", "r3"] {
write_stored(&stored_with(refresh)).unwrap();
+3 -29
View File
@@ -457,26 +457,7 @@ fn load_config_at(path: &Path) -> AppConfig {
/// [`AppDirs::save_config`] for the file at `path`.
fn save_config_at(path: &Path, config: &AppConfig) -> Result<()> {
refuse_to_replace_unreadable(path)?;
let parent = path
.parent()
.ok_or_else(|| Error::Other("configuration path has no parent".into()))?;
std::fs::create_dir_all(parent)?;
let nonce = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map(|duration| duration.as_nanos())
.unwrap_or(0);
let tmp = path.with_extension(format!("json.tmp-{}-{nonce}", std::process::id()));
use std::os::unix::fs::OpenOptionsExt as _;
let mut file = std::fs::OpenOptions::new()
.write(true)
.create_new(true)
.mode(0o600)
.open(&tmp)?;
use std::io::Write as _;
file.write_all(&serde_json::to_vec_pretty(config)?)?;
file.sync_all()?;
std::fs::rename(&tmp, path)?;
std::fs::File::open(parent)?.sync_all()?;
proton_base_rs::atomic::write(path, &serde_json::to_vec_pretty(config)?)?;
Ok(())
}
@@ -621,15 +602,8 @@ impl AppDirs {
use std::io::Read as _;
std::fs::File::open("/dev/urandom")?.read_exact(&mut bytes)?;
let id: String = bytes.iter().map(|b| format!("{b:02x}")).collect();
let parent = path
.parent()
.ok_or_else(|| Error::Other("machine id path has no parent".into()))?;
std::fs::create_dir_all(parent)?;
let tmp = path.with_extension(format!("tmp-{}", std::process::id()));
std::fs::write(&tmp, format!("{id}\n"))?;
std::fs::File::open(&tmp)?.sync_all()?;
std::fs::rename(&tmp, &path)?;
std::fs::File::open(parent)?.sync_all()?;
// Not secret, and other tools may read it; keep it world-readable.
proton_base_rs::atomic::write_with_mode(&path, format!("{id}\n").as_bytes(), 0o644)?;
Ok(id)
}
+5 -41
View File
@@ -1740,27 +1740,6 @@ pub enum PhotoKind {
Raw,
}
/// File-name extensions that denote a video, matched case-insensitively.
const VIDEO_EXTS: &[&str] = &[
"mkv", "mp4", "mov", "avi", "webm", "m4v", "flv", "wmv", "mpg", "mpeg", "ts", "3gp", "m2ts",
"mts", "ogv",
];
/// File-name extensions that denote a camera raw. The server media type for
/// these is frequently a generic `application/octet-stream`, so the extension is
/// the authoritative signal.
const RAW_EXTS: &[&str] = &[
"cr2", "cr3", "nef", "nrw", "arw", "srf", "sr2", "dng", "raf", "orf", "rw2", "srw", "pef",
"raw", "rwl", "iiq", "3fr", "dcr", "kdc", "mrw", "x3f",
];
/// File-name extensions that denote a ready-to-view still photo. Listed so a
/// known image name classifies as a photo outright, without deferring to a media
/// type that might disagree.
const PHOTO_EXTS: &[&str] = &[
"jpg", "jpeg", "png", "gif", "webp", "heic", "heif", "avif", "bmp", "tif", "tiff",
];
impl PhotoKind {
/// Classify a photo from what the daemon knows about it. A recognised
/// file-name extension is authoritative — it is reliable even before the
@@ -1768,26 +1747,11 @@ impl PhotoKind {
/// useless generic — so the media type is only consulted for names that carry
/// no extension we know. Anything still unresolved is a still photo.
pub fn classify(name: Option<&str>, media_type: Option<&str>) -> PhotoKind {
if let Some(ext) = name
.and_then(|n| n.rsplit_once('.'))
.map(|(_, e)| e.to_ascii_lowercase())
{
if RAW_EXTS.contains(&ext.as_str()) {
return PhotoKind::Raw;
}
if VIDEO_EXTS.contains(&ext.as_str()) {
return PhotoKind::Video;
}
if PHOTO_EXTS.contains(&ext.as_str()) {
return PhotoKind::Photo;
}
match proton_gallery_rs::grouping::MediaClass::classify(name, media_type) {
proton_gallery_rs::grouping::MediaClass::Photo => PhotoKind::Photo,
proton_gallery_rs::grouping::MediaClass::Video => PhotoKind::Video,
proton_gallery_rs::grouping::MediaClass::Raw => PhotoKind::Raw,
}
if let Some(mt) = media_type
&& mt.starts_with("video/")
{
return PhotoKind::Video;
}
PhotoKind::Photo
}
/// The stable integer this kind is persisted as (see the `kind` column of the
@@ -3196,7 +3160,7 @@ mod tests {
/// videos back to the expensive whole-file path.
#[test]
fn photo_kind_recognises_every_supported_video_extension() {
for ext in VIDEO_EXTS {
for ext in proton_gallery_rs::grouping::VIDEO_EXTENSIONS {
let lower = format!("movie.{ext}");
let upper = format!("MOVIE.{}", ext.to_ascii_uppercase());
assert_eq!(
+5 -131
View File
@@ -5,6 +5,8 @@ use rusqlite::{Connection, OptionalExtension, Transaction, params};
use std::collections::{HashMap, HashSet};
use proton_gallery_rs::grouping::{Grouped, group_photos, name_stem};
use super::Db;
use crate::Result;
@@ -121,135 +123,6 @@ fn capture_day(conn: &rusqlite::Connection, capture_time: i64) -> Option<String>
.flatten()
}
/// The file name without its extension, lowercased — `IMG_1234.CR2` and
/// `IMG_1234.JPG` share `img_1234` — with the camera's own part-of-a-shot
/// marker removed, so the two files a raw capture writes share a stem too.
fn name_stem(name: Option<&str>) -> Option<String> {
let name = name?;
let stem = match name.rsplit_once('.') {
Some((stem, _)) if !stem.is_empty() => stem,
_ => name,
};
let stem = stem.to_ascii_lowercase();
Some(strip_shot_marker(&stem).to_string())
}
/// Drop a `.RAW-NN.ROLE` marker from a stem.
///
/// Pixel stores one raw capture as `PXL_20260919_000625670.RAW-01.COVER.jpg`
/// and `PXL_20260919_000625670.RAW-02.ORIGINAL.dng`: one shot, two files, two
/// stems that differ in exactly the part naming which file of the shot this is.
/// Cutting the marker off is what lets rule 2 see the pair. The check is narrow
/// on purpose — digits, then a single role word — so an ordinary name that
/// happens to contain `.raw-` keeps its stem.
fn strip_shot_marker(stem: &str) -> &str {
let Some(at) = stem.rfind(".raw-") else {
return stem;
};
let rest = &stem[at + ".raw-".len()..];
let Some((index, role)) = rest.split_once('.') else {
return stem;
};
let marked = !index.is_empty()
&& index.bytes().all(|b| b.is_ascii_digit())
&& !role.is_empty()
&& role.bytes().all(|b| b.is_ascii_alphabetic());
if marked { &stem[..at] } else { stem }
}
/// One entry of the grouping pass: what rule 2 needs, plus what choosing a
/// representative needs.
struct Grouped {
uid: String,
kind: crate::control::PhotoKind,
main_uid: Option<String>,
day: Option<String>,
stem: Option<String>,
}
/// Which group each photo belongs to, and which member of it the gallery shows.
///
/// Precedence, as agreed:
///
/// 1. The server's own relation — a photo with a `main_photo_uid` joins that
/// photo's group. The server knows about live photos and bursts; we do not
/// have to guess at them.
/// 2. Otherwise, same capture day **and** same file-name stem **and** one of the
/// two is a camera raw while the other is not. That is the RAW+JPEG pair a
/// camera writes, and the differing-kind clause keeps two JPEGs that happen
/// to share a name apart.
/// 3. Otherwise the photo is its own group.
///
/// The representative is the non-raw member when the group has one — a JPEG
/// decodes in milliseconds and is what the person expects to see — and the
/// earliest member in server order otherwise.
fn group_photos(entries: &[Grouped]) -> Vec<String> {
let mut parent: Vec<usize> = (0..entries.len()).collect();
fn find(parent: &mut [usize], mut i: usize) -> usize {
while parent[i] != i {
parent[i] = parent[parent[i]];
i = parent[i];
}
i
}
let union = |parent: &mut [usize], a: usize, b: usize| {
let (a, b) = (find(parent, a), find(parent, b));
if a != b {
parent[b] = a;
}
};
let index: HashMap<&str, usize> = entries
.iter()
.enumerate()
.map(|(i, e)| (e.uid.as_str(), i))
.collect();
for (i, entry) in entries.iter().enumerate() {
if let Some(main) = entry.main_uid.as_deref()
&& let Some(&j) = index.get(main)
{
union(&mut parent, j, i);
}
}
// Rule 2 needs only one pass: everything sharing a day and a stem lands in
// the same bucket, and the raw / non-raw split is checked pairwise there.
let mut by_name: HashMap<(&str, &str), Vec<usize>> = HashMap::new();
for (i, entry) in entries.iter().enumerate() {
if let (Some(day), Some(stem)) = (entry.day.as_deref(), entry.stem.as_deref()) {
by_name.entry((day, stem)).or_default().push(i);
}
}
let is_raw = |i: usize| entries[i].kind == crate::control::PhotoKind::Raw;
for bucket in by_name.values() {
for (n, &i) in bucket.iter().enumerate() {
for &j in &bucket[n + 1..] {
if is_raw(i) != is_raw(j) {
union(&mut parent, i, j);
}
}
}
}
// Representative per root, then the key every member carries.
let mut representative: HashMap<usize, usize> = HashMap::new();
for i in 0..entries.len() {
let root = find(&mut parent, i);
match representative.get(&root).copied() {
Some(current) if !is_raw(current) || is_raw(i) => {}
_ => {
representative.insert(root, i);
}
}
}
(0..entries.len())
.map(|i| {
let root = find(&mut parent, i);
entries[representative[&root]].uid.clone()
})
.collect()
}
/// The columns every photo read selects, with the group aggregates joined in.
/// `g.n` is how many photos the group holds and `g.raw` whether any of them is a
/// camera raw file — one query rather than a second lookup per tile.
@@ -483,7 +356,8 @@ impl Db {
Ok((
Grouped {
uid: r.get(0)?,
kind: crate::control::PhotoKind::from_i64(r.get(1)?),
raw: crate::control::PhotoKind::from_i64(r.get(1)?)
== crate::control::PhotoKind::Raw,
main_uid: r.get(2)?,
day: r.get(3)?,
stem: name_stem(name.as_deref()),
@@ -640,7 +514,7 @@ impl Db {
.iter()
.map(|(row, carried, kind)| Grouped {
uid: row.uid.clone(),
kind: *kind,
raw: *kind == crate::control::PhotoKind::Raw,
main_uid: carried.main_uid.clone(),
day: capture_day(&tx, row.capture_time),
stem: name_stem(carried.name.as_deref()),
+17
View File
@@ -42,6 +42,13 @@ pub enum Error {
#[error("that mailbox password does not unlock your account")]
WrongMailboxPassword,
/// The account's only second factor is a security key, which needs
/// WebAuthn. Asking for a code would only fail as a wrong one.
#[error(
"this account's only second factor is a security key, which pdfs cannot use yet — add an authenticator app in your Proton account settings"
)]
SecurityKeyOnly,
/// The login was gated behind human verification. Not a failure the user can
/// fix by retrying: the challenge has to be solved and the login restarted
/// with the resulting token (see [`auth::login_verified`](crate::auth::login_verified)).
@@ -220,6 +227,7 @@ fn core_kind(e: &Error) -> ErrorKind {
| Error::ReloginRequired
| Error::Locked
| Error::WrongMailboxPassword
| Error::SecurityKeyOnly
| Error::HumanVerificationRequired(_) => ErrorKind::Denied,
Error::Proton(proton) => proton_kind(proton),
_ => ErrorKind::Internal,
@@ -347,6 +355,15 @@ pub fn sign_in_blocked(e: &proton_sdk::ProtonError) -> bool {
/// The result every request-serving method in the daemon returns.
pub type CoreResult<T> = std::result::Result<T, CoreError>;
impl From<proton_auth_rs::Error> for Error {
fn from(error: proton_auth_rs::Error) -> Self {
match error {
proton_auth_rs::Error::Keyring(error) => Self::Keyring(error),
other => Self::Other(other.to_string()),
}
}
}
#[cfg(test)]
mod tests {
use super::*;
-133
View File
@@ -1,133 +0,0 @@
//! When a photo was taken, as its own EXIF tags say.
//!
//! The fallback for a photo nothing else dates: a Takeout photo without a
//! sidecar or a date in its name, and a photo uploaded from the app. Without
//! it the first was filed under the moment of the import and the second under
//! the file's modification time, which a copy resets.
use std::io::{BufRead, Seek};
use std::path::Path;
use crate::takeout::days_from_civil;
/// The capture time in the EXIF of the file at `path`, in epoch seconds.
pub fn capture_time_of(path: &Path) -> Option<i64> {
let file = std::fs::File::open(path).ok()?;
capture_time(&mut std::io::BufReader::new(file))
}
/// The capture time in the EXIF `reader` holds: `DateTimeOriginal`, then
/// `DateTimeDigitized`, each adjusted by its `OffsetTime…` tag when the camera
/// wrote one. Without an offset the time is read as UTC, as a date in a file
/// name is (`takeout::capture_time_from_name`).
pub fn capture_time(reader: &mut (impl BufRead + Seek)) -> Option<i64> {
let exif = exif::Reader::new().read_from_container(reader).ok()?;
let ascii = |tag: exif::Tag| -> Option<String> {
let field = exif.get_field(tag, exif::In::PRIMARY)?;
match &field.value {
exif::Value::Ascii(parts) => parts.first().map(|part| {
String::from_utf8_lossy(part)
.trim_matches('\0')
.trim()
.to_string()
}),
_ => None,
}
};
[
(exif::Tag::DateTimeOriginal, exif::Tag::OffsetTimeOriginal),
(exif::Tag::DateTimeDigitized, exif::Tag::OffsetTimeDigitized),
]
.into_iter()
.find_map(|(time, offset)| {
let local = parse_exif_time(&ascii(time)?)?;
let offset = ascii(offset).and_then(|o| parse_offset(&o)).unwrap_or(0);
Some(local - offset)
})
}
/// `YYYY:MM:DD HH:MM:SS` as epoch seconds, read as UTC. `None` for the
/// all-zero or blank value cameras write when they do not know.
fn parse_exif_time(text: &str) -> Option<i64> {
let bytes = text.as_bytes();
if bytes.len() < 19 || bytes[4] != b':' || bytes[7] != b':' || bytes[13] != b':' {
return None;
}
let number = |range: std::ops::Range<usize>| text.get(range)?.parse::<i64>().ok();
let (year, month, day) = (number(0..4)?, number(5..7)?, number(8..10)?);
let (hour, minute, second) = (number(11..13)?, number(14..16)?, number(17..19)?);
if !(1800..=9999).contains(&year)
|| !(1..=12).contains(&month)
|| !(1..=31).contains(&day)
|| hour > 23
|| minute > 59
|| second > 60
{
return None;
}
Some(days_from_civil(year, month, day) * 86_400 + hour * 3600 + minute * 60 + second)
}
/// `+HH:MM` or `-HH:MM` as seconds east of UTC.
fn parse_offset(text: &str) -> Option<i64> {
let sign = match text.as_bytes().first()? {
b'+' => 1,
b'-' => -1,
_ => return None,
};
let (hours, minutes) = text.get(1..)?.split_once(':')?;
let (hours, minutes) = (hours.parse::<i64>().ok()?, minutes.parse::<i64>().ok()?);
(hours <= 14 && minutes < 60).then_some(sign * (hours * 3600 + minutes * 60))
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn an_exif_time_reads_as_utc_and_its_offset_moves_it() {
// 2023-06-01 12:00:00 UTC.
let noon = 1_685_620_800;
assert_eq!(parse_exif_time("2023:06:01 12:00:00"), Some(noon));
assert_eq!(parse_offset("+02:00"), Some(7200));
assert_eq!(parse_offset("-05:30"), Some(-19_800));
assert_eq!(
parse_exif_time("2023:06:01 14:00:00").map(|t| t - parse_offset("+02:00").unwrap()),
Some(noon)
);
}
#[test]
fn an_unknown_exif_time_is_no_time() {
assert_eq!(parse_exif_time("0000:00:00 00:00:00"), None);
assert_eq!(parse_exif_time(" : : : : "), None);
assert_eq!(parse_exif_time(""), None);
assert_eq!(parse_offset("02:00"), None);
}
#[test]
fn a_photo_is_dated_by_its_original_time_and_offset() {
let ascii = |tag, text: &str| exif::Field {
tag,
ifd_num: exif::In::PRIMARY,
value: exif::Value::Ascii(vec![text.as_bytes().to_vec()]),
};
let taken = ascii(exif::Tag::DateTimeOriginal, "2023:06:01 14:00:00");
let offset = ascii(exif::Tag::OffsetTimeOriginal, "+02:00");
let digitized = ascii(exif::Tag::DateTimeDigitized, "2024:01:01 00:00:00");
let mut writer = exif::experimental::Writer::new();
writer.push_field(&taken);
writer.push_field(&offset);
writer.push_field(&digitized);
let mut tiff = std::io::Cursor::new(Vec::new());
writer.write(&mut tiff, false).unwrap();
tiff.set_position(0);
assert_eq!(capture_time(&mut tiff), Some(1_685_620_800));
}
#[test]
fn a_file_without_exif_has_no_capture_time() {
let mut png = std::io::Cursor::new(b"\x89PNG\r\n\x1a\n".to_vec());
assert_eq!(capture_time(&mut png), None);
}
}
+3 -5
View File
@@ -10,7 +10,6 @@ pub mod config;
pub mod control;
pub mod db;
pub mod error;
pub mod exiftime;
pub mod kernelkey;
pub mod keycheck;
pub mod localindex;
@@ -19,21 +18,20 @@ pub mod mountfail;
pub mod mountpoint;
pub mod mounts;
pub mod opener;
pub mod places;
pub mod profile;
pub mod sdkcache;
pub mod search;
mod secretservice;
pub mod service;
pub mod shell;
pub mod similar;
pub mod syncignore;
pub mod syncroot;
pub mod takeout;
pub mod timestamp;
pub mod tray;
pub mod update;
// Photo logic shared with Proton Gallery through the proton-rs crates.
pub use proton_gallery_rs::{exiftime, places, similar, takeout};
pub use access::{Access, access_for, perm_bits};
pub use error::{CoreError, CoreResult, Error, Result};
+1 -3
View File
@@ -40,9 +40,7 @@ pub fn path(state_dir: &Path) -> PathBuf {
/// and renamed, so a reader never sees half of it.
pub fn record(state_dir: &Path, failure: &MountFailure) -> std::io::Result<()> {
let json = serde_json::to_vec(failure).map_err(std::io::Error::other)?;
let tmp = state_dir.join(format!("{FILE_NAME}.tmp"));
std::fs::write(&tmp, json)?;
std::fs::rename(&tmp, path(state_dir))
proton_base_rs::atomic::write_with_mode(&path(state_dir), &json, 0o644)
}
/// Forget the failure: a mount is up, or a new daemon has started.
-185
View File
@@ -1,185 +0,0 @@
//! Offline reverse geocoding: the town a photo was taken in, from its GPS
//! position, without asking any service.
//!
//! The towns are GeoNames' `cities15000` dump (every place with more than
//! 15,000 people), trimmed to id, name, position and country in
//! `data/cities15000.tsv` by `scripts/geonames-cities.py`. The script drops the
//! parts of a city, such as Kreuzberg or "Paris 15 Vaugirard", so that a photo
//! lands in the town people would name. GeoNames publishes the dump under
//! CC BY 4.0, which is why the About dialog credits it.
//!
//! `data/countries.tsv` maps each country code to its ISO 3166-1 English name,
//! as the `iso-codes` project spells it, so a front end can translate it
//! through that project's `iso_3166-1` gettext domain.
use std::collections::HashMap;
use std::sync::OnceLock;
/// How far from the nearest town a photo may be and still count as taken
/// there, in km. Farther out (at sea, in the wilderness) it has no place.
pub const MAX_DISTANCE_KM: f64 = 50.0;
/// Mean Earth radius in km, for the haversine distance.
const EARTH_RADIUS_KM: f64 = 6371.0;
const CITIES: &str = include_str!("../data/cities15000.tsv");
const COUNTRIES: &str = include_str!("../data/countries.tsv");
/// One town of the table.
#[derive(Debug, Clone, PartialEq)]
pub struct City {
/// The GeoNames id, stable across dumps.
pub id: u32,
pub name: &'static str,
pub latitude: f64,
pub longitude: f64,
/// ISO 3166-1 alpha-2 country code.
pub country: &'static str,
}
/// The towns, and an index of them by whole-degree cell.
struct Table {
cities: Vec<City>,
cells: HashMap<(i32, i32), Vec<usize>>,
}
fn table() -> &'static Table {
static TABLE: OnceLock<Table> = OnceLock::new();
TABLE.get_or_init(|| {
let cities: Vec<City> = CITIES.lines().filter_map(parse_city).collect();
let mut cells: HashMap<(i32, i32), Vec<usize>> = HashMap::new();
for (index, city) in cities.iter().enumerate() {
cells
.entry(cell(city.latitude, city.longitude))
.or_default()
.push(index);
}
Table { cities, cells }
})
}
fn parse_city(line: &'static str) -> Option<City> {
let mut fields = line.split('\t');
Some(City {
id: fields.next()?.parse().ok()?,
name: fields.next()?,
latitude: fields.next()?.parse().ok()?,
longitude: fields.next()?.parse().ok()?,
country: fields.next()?,
})
}
fn cell(latitude: f64, longitude: f64) -> (i32, i32) {
(latitude.floor() as i32, longitude.floor() as i32)
}
/// Great-circle distance between two positions, in km.
pub fn distance_km(a: (f64, f64), b: (f64, f64)) -> f64 {
let (lat1, lat2) = (a.0.to_radians(), b.0.to_radians());
let dlat = lat2 - lat1;
let dlon = (b.1 - a.1).to_radians();
let h = (dlat / 2.0).sin().powi(2) + lat1.cos() * lat2.cos() * (dlon / 2.0).sin().powi(2);
2.0 * EARTH_RADIUS_KM * h.sqrt().min(1.0).asin()
}
/// The town nearest to a position, if one lies within [`MAX_DISTANCE_KM`].
pub fn nearest(latitude: f64, longitude: f64) -> Option<&'static City> {
if !latitude.is_finite() || !longitude.is_finite() {
return None;
}
let table = table();
// A degree of latitude is about 111 km everywhere; a degree of longitude
// shrinks towards the poles, so more cells are needed to cover the radius.
let lat_span = (MAX_DISTANCE_KM / 111.0).ceil() as i32;
let lon_span = {
let scale = latitude.to_radians().cos().abs().max(0.01);
((MAX_DISTANCE_KM / (111.0 * scale)).ceil() as i32).min(180)
};
let (row, column) = cell(latitude, longitude);
let mut best: Option<(f64, &City)> = None;
for dlat in -lat_span..=lat_span {
for dlon in -lon_span..=lon_span {
// Longitude wraps at the antimeridian: -181 is 179.
let lon_cell = (column + dlon + 180).rem_euclid(360) - 180;
let Some(indices) = table.cells.get(&(row + dlat, lon_cell)) else {
continue;
};
for &index in indices {
let city = &table.cities[index];
let d = distance_km((latitude, longitude), (city.latitude, city.longitude));
if d <= MAX_DISTANCE_KM && best.is_none_or(|(bd, _)| d < bd) {
best = Some((d, city));
}
}
}
}
best.map(|(_, city)| city)
}
/// The town with this GeoNames id.
pub fn city(id: u32) -> Option<&'static City> {
let cities = &table().cities;
// The table is sorted by id.
cities
.binary_search_by_key(&id, |city| city.id)
.ok()
.map(|index| &cities[index])
}
/// The English ISO 3166-1 name of a country code, such as "Germany" for "DE".
pub fn country_name(code: &str) -> Option<&'static str> {
COUNTRIES.lines().find_map(|line| {
let (c, name) = line.split_once('\t')?;
(c == code).then_some(name)
})
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn a_position_in_a_town_resolves_to_that_town() {
let berlin = nearest(52.52, 13.405).expect("Berlin is a town");
assert_eq!(berlin.name, "Berlin");
assert_eq!(berlin.country, "DE");
assert_eq!(city(berlin.id), Some(berlin));
}
#[test]
fn the_open_sea_has_no_town() {
assert_eq!(nearest(0.0, -30.0), None);
assert_eq!(nearest(f64::NAN, 0.0), None);
}
#[test]
fn a_town_across_the_antimeridian_is_still_found() {
// Just east of 180°, the nearest towns in Fiji are west of it.
let town = nearest(-16.8, 179.99);
assert!(town.is_none_or(|t| t.country == "FJ"));
let suva = nearest(-18.14, 178.44).expect("Suva is a town");
assert_eq!(suva.country, "FJ");
}
#[test]
fn every_town_has_a_named_country() {
for city in &table().cities {
assert!(
country_name(city.country).is_some(),
"{} has no country name for {}",
city.name,
city.country
);
}
assert_eq!(country_name("DE"), Some("Germany"));
}
#[test]
fn distances_are_great_circle_km() {
let d = distance_km((52.52, 13.405), (48.137, 11.575));
assert!(
(d - 504.0).abs() < 5.0,
"Berlin to Munich is about 504 km, got {d}"
);
}
}
-135
View File
@@ -1,135 +0,0 @@
//! Saving a new secret into an existing Secret Service item by replacing the
//! item, not by editing its secret (`docs/BUGS.md` B291).
//!
//! oo7-daemon before 0.7.0 applies `SetSecret` only in memory: the keyring
//! file keeps the old secret, and it comes back once the daemon restarts.
//! Fedora 45 ships such a build (`0.7.0~beta^1.e91b98a`). Every refreshed
//! sign-in pdfs saved there was gone after a reboot, and the next start found
//! a refresh token Proton had already spent.
//!
//! `CreateItem` with `replace` is written to the file there, and every
//! provider implements it. So a secret that changes is written as a new item
//! that replaces the old one: in the old one's collection, with its label and
//! all of its attributes, so the provider recognises it as the same entry.
use dbus_secret_service::{Collection, EncryptionType, Path, SecretService};
use std::collections::HashMap;
/// The content type the keyring store writes its secrets with.
const CONTENT_TYPE: &str = "application/octet-stream";
/// What [`replace`] did.
#[derive(Debug, PartialEq, Eq)]
pub(crate) enum Replaced {
/// The secret is saved.
Saved,
/// Nothing was changed; save it the usual way. Says why, for the log.
Skipped(String),
}
/// Save `secret` into the one item for `service`/`user` by replacing it.
///
/// Skips, changing nothing, when there is no such item yet (the store creates
/// it), when there is more than one, when it is locked, or when the Secret
/// Service fails before the new item exists. Never shows a prompt: one would
/// block the caller, so it is dismissed and the write is skipped.
pub(crate) fn replace(service: &str, user: &str, secret: &[u8]) -> Replaced {
match try_replace(service, user, secret) {
Ok(replaced) => replaced,
Err(e) => Replaced::Skipped(e.to_string()),
}
}
fn try_replace(
service: &str,
user: &str,
secret: &[u8],
) -> Result<Replaced, dbus_secret_service::Error> {
let ss = SecretService::connect_with_max_prompt_timeout(EncryptionType::Dh, 0)?;
let lookup = HashMap::from([("service", service), ("username", user)]);
let found = ss.search_items(lookup.clone())?;
if !found.locked.is_empty() {
return Ok(Replaced::Skipped("the item is locked".into()));
}
let [old] = found.unlocked.as_slice() else {
return Ok(Replaced::Skipped(format!(
"{} items match, not one",
found.unlocked.len()
)));
};
let Some(collection) = collection_of(&old.path) else {
return Ok(Replaced::Skipped(format!(
"no collection in the item path {}",
old.path
)));
};
let label = old.get_label()?;
let attributes = old.get_attributes()?;
let attributes: HashMap<&str, &str> = attributes
.iter()
.map(|(k, v)| (k.as_str(), v.as_str()))
.collect();
let collection = Collection::new(&ss, collection);
let new = collection.create_item(&label, attributes, secret, true, CONTENT_TYPE)?;
// A provider that did not match the old item leaves it next to the new
// one, and two items make every read ambiguous.
let after = ss.search_items(lookup)?;
for item in after.unlocked.iter().chain(&after.locked) {
if item.path == new.path {
continue;
}
if let Err(e) = item.delete() {
// The old item still holds the previous secret, so taking the new
// one out leaves things as they were, for the usual write.
if let Err(undo) = new.delete() {
tracing::error!(
error = %undo,
"could not remove a duplicate keyring item; remove one of the two \
`proton-drive-linux` entries in your keyring and sign in again"
);
}
return Ok(Replaced::Skipped(format!(
"could not remove the replaced item: {e}"
)));
}
}
Ok(Replaced::Saved)
}
/// The collection an item path belongs to: the path without its last part,
/// as long as it is a Secret Service object path.
fn collection_of(item: &Path<'_>) -> Option<Path<'static>> {
let (collection, _) = item.rsplit_once('/')?;
if !collection.starts_with("/org/freedesktop/secrets/") || collection.ends_with('/') {
return None;
}
Path::new(collection.to_owned()).ok()
}
#[cfg(test)]
mod tests {
use super::*;
fn collection(item: &str) -> Option<String> {
collection_of(&Path::new(item).unwrap()).map(|p| p.to_string())
}
#[test]
fn an_item_belongs_to_the_collection_its_path_names() {
assert_eq!(
collection("/org/freedesktop/secrets/collection/login/14").as_deref(),
Some("/org/freedesktop/secrets/collection/login")
);
assert_eq!(
collection("/org/freedesktop/secrets/aliases/default/3").as_deref(),
Some("/org/freedesktop/secrets/aliases/default")
);
}
#[test]
fn a_path_outside_the_secret_service_names_no_collection() {
assert_eq!(collection("/org/example/item/1"), None);
assert_eq!(collection("/item"), None);
}
}
-193
View File
@@ -1,193 +0,0 @@
//! Telling photos apart by what they show rather than by their bytes.
//!
//! The server's content hash only matches byte-identical files. A photo that
//! was resized, re-encoded or sent through a messenger is another file, so the
//! similar-photo finder hashes each thumbnail instead: a 64-bit difference
//! hash ("dHash"), which compares neighbouring brightness in a 9×8 grid. Two
//! copies of one picture land a few bits apart, and different pictures about
//! half of the bits apart.
/// Hashes this many bits apart or fewer show the same picture.
pub const SIMILAR_BITS: u32 = 6;
/// Stored for a photo whose thumbnail was looked at and gave no usable hash
/// (it couldn't be decoded, or is one flat colour), so it isn't looked at
/// again. A real hash is never 0: a picture that would hash to 0 has no
/// brightness changes, which [`difference_hash`] turns down as flat.
pub const NO_HASH: u64 = 0;
/// Samples of the grid that differ by less than this in brightness, all of
/// them, make a flat picture — a black frame, a blank page — whose hash is
/// noise and would match every other flat picture.
const FLAT: u8 = 8;
/// The difference hash of an 8-bit greyscale image `width` px wide, rows
/// stored one after another in `luma`. `None` for an empty or flat image.
pub fn difference_hash(width: usize, height: usize, luma: &[u8]) -> Option<u64> {
if width == 0 || height == 0 || luma.len() < width * height {
return None;
}
// Box-average down to 9×8, so every source pixel counts once and the hash
// doesn't depend on which pixels a nearest-neighbour pick happens to hit.
let mut grid = [[0u8; 9]; 8];
for (gy, row) in grid.iter_mut().enumerate() {
let (y0, y1) = span(gy, 8, height);
for (gx, cell) in row.iter_mut().enumerate() {
let (x0, x1) = span(gx, 9, width);
let mut sum = 0u64;
for y in y0..y1 {
sum += luma[y * width + x0..y * width + x1]
.iter()
.map(|&v| u64::from(v))
.sum::<u64>();
}
*cell = (sum / ((y1 - y0) * (x1 - x0)) as u64) as u8;
}
}
let (min, max) = grid
.iter()
.flatten()
.fold((u8::MAX, 0), |(min, max), &v| (min.min(v), max.max(v)));
if max - min < FLAT {
return None;
}
let mut hash = 0u64;
for row in &grid {
for pair in row.windows(2) {
hash = hash << 1 | u64::from(pair[0] < pair[1]);
}
}
(hash != NO_HASH).then_some(hash)
}
/// The source pixels `from..to` that cell `i` of `cells` covers along an edge
/// of `len` px; never empty, even for an edge shorter than the grid.
fn span(i: usize, cells: usize, len: usize) -> (usize, usize) {
let from = (i * len / cells).min(len - 1);
let to = ((i + 1) * len / cells).max(from + 1);
(from, to)
}
/// Whether two hashes show the same picture.
pub fn alike(a: u64, b: u64) -> bool {
(a ^ b).count_ones() <= SIMILAR_BITS
}
/// Group `hashes` into sets of alike ones, by index, each set in index order
/// and the sets by their first index. A hash alike to none other is in no
/// set. Alike is taken as catching: a burst of shots each a little different
/// from the last is one set.
pub fn sets(hashes: &[u64]) -> Vec<Vec<usize>> {
// Two hashes at most SIMILAR_BITS apart agree on at least one of their
// eight bytes, as long as SIMILAR_BITS < 8. So only hashes sharing some
// byte are compared, not every pair of the library.
const _: () = assert!(SIMILAR_BITS < 8);
let mut parent: Vec<usize> = (0..hashes.len()).collect();
fn root(parent: &mut [usize], mut i: usize) -> usize {
while parent[i] != i {
parent[i] = parent[parent[i]];
i = parent[i];
}
i
}
for byte in 0..8 {
let mut buckets: Vec<Vec<usize>> = vec![Vec::new(); 256];
for (i, &hash) in hashes.iter().enumerate() {
buckets[(hash >> (byte * 8)) as u8 as usize].push(i);
}
for bucket in &buckets {
for (n, &a) in bucket.iter().enumerate() {
for &b in &bucket[n + 1..] {
if alike(hashes[a], hashes[b]) {
let (ra, rb) = (root(&mut parent, a), root(&mut parent, b));
if ra != rb {
parent[ra.max(rb)] = ra.min(rb);
}
}
}
}
}
}
let mut by_root: std::collections::BTreeMap<usize, Vec<usize>> = Default::default();
for i in 0..hashes.len() {
let r = root(&mut parent, i);
by_root.entry(r).or_default().push(i);
}
by_root.into_values().filter(|set| set.len() > 1).collect()
}
#[cfg(test)]
mod tests {
use super::*;
/// A 90×80 picture: a bright disc on a gradient.
fn picture(width: usize, height: usize) -> Vec<u8> {
let mut luma = Vec::with_capacity(width * height);
for y in 0..height {
for x in 0..width {
let (fx, fy) = (x as f64 / width as f64, y as f64 / height as f64);
let disc = ((fx - 0.3).powi(2) + (fy - 0.6).powi(2)).sqrt() < 0.2;
let v = if disc { 240.0 } else { 40.0 + 120.0 * fx * fy };
luma.push(v as u8);
}
}
luma
}
#[test]
fn a_resized_copy_hashes_alike() {
let big = difference_hash(900, 800, &picture(900, 800)).unwrap();
let small = difference_hash(91, 79, &picture(91, 79)).unwrap();
assert!(
alike(big, small),
"{} bits apart",
(big ^ small).count_ones()
);
}
#[test]
fn a_different_picture_hashes_apart() {
let one = difference_hash(90, 80, &picture(90, 80)).unwrap();
let mirrored: Vec<u8> = picture(90, 80)
.chunks(90)
.flat_map(|row| row.iter().rev().copied().collect::<Vec<_>>())
.collect();
let other = difference_hash(90, 80, &mirrored).unwrap();
assert!(!alike(one, other));
}
#[test]
fn a_flat_picture_has_no_hash() {
assert_eq!(difference_hash(64, 64, &[17; 64 * 64]), None);
assert_eq!(difference_hash(0, 0, &[]), None);
assert_eq!(difference_hash(4, 4, &[0; 3]), None);
}
#[test]
fn a_picture_smaller_than_the_grid_still_hashes() {
let luma: Vec<u8> = (0..4 * 3).map(|i| (i * 20) as u8).collect();
assert!(difference_hash(4, 3, &luma).is_some());
}
#[test]
fn alike_hashes_form_sets_and_catch_on() {
let a = 0x0123_4567_89ab_cdef_u64;
let hashes = [
a,
!a,
a ^ 0b111,
a ^ 0b111 ^ (0b1111 << 40),
0x5555_0000_ffff_aaaa,
];
assert_eq!(sets(&hashes), vec![vec![0, 2, 3]]);
}
#[test]
fn hashes_apart_in_most_bytes_are_still_found() {
// One bit apart in each of six bytes: six bits in all, and only the
// top two bytes agree.
let a = 1u64 << 63;
let b = (0..6).fold(a, |h, byte| h | 1 << (byte * 8));
assert_eq!(sets(&[a, b]), vec![vec![0, 1]]);
}
}
File diff suppressed because it is too large. Load diff
+3 -2
View File
@@ -14,8 +14,9 @@ pdfs-core.workspace = true
zip.workspace = true
sha1.workspace = true
proton-drive-rs.workspace = true
pg-app.workspace = true
pg-core.workspace = true
proton-gallery-app-rs.workspace = true
proton-gallery-rs.workspace = true
proton-media-rs.workspace = true
hyper = { version = "1", features = ["http1", "server"] }
hyper-util = { version = "0.1", features = ["tokio"] }
http-body-util = "0.1"
+12 -9
View File
@@ -14,10 +14,10 @@ use pdfs_core::control::{
GalleryAction, GalleryAlbum, GalleryFolder, GalleryPlace, PhotoItem, PhotoKind, Response,
};
use pdfs_core::{CoreError, CoreResult};
use pg_app::{App, View};
use pg_core::CancellationToken;
use pg_core::model::{AssetKey, SourceId};
use proton_drive_rs::proton_sdk::session::ProtonApiSession;
use proton_gallery_app_rs::{App, View};
use proton_gallery_rs::CancellationToken;
use proton_gallery_rs::model::{AssetKey, SourceId};
use tokio::sync::{Mutex, Notify, OnceCell};
use super::{Core, NodeUid, parse_uid};
@@ -187,8 +187,9 @@ impl Gallery {
Ok(Arc::new(visibility))
}
fn account(&self) -> CoreResult<pg_core::model::AccountId> {
pg_core::model::AccountId::new(self.session.user_id().as_str()).map_err(gallery_error)
fn account(&self) -> CoreResult<proton_gallery_rs::model::AccountId> {
proton_gallery_rs::model::AccountId::new(self.session.user_id().as_str())
.map_err(gallery_error)
}
async fn page(
@@ -345,13 +346,15 @@ impl Gallery {
fn asset(&self, uid: &NodeUid) -> CoreResult<AssetKey> {
Ok(AssetKey {
account: self.account()?,
volume: pg_core::model::VolumeId::new(uid.volume_id.as_str()).map_err(gallery_error)?,
node: pg_core::model::NodeId::new(uid.link_id.as_str()).map_err(gallery_error)?,
volume: proton_gallery_rs::model::VolumeId::new(uid.volume_id.as_str())
.map_err(gallery_error)?,
node: proton_gallery_rs::model::NodeId::new(uid.link_id.as_str())
.map_err(gallery_error)?,
})
}
}
fn gallery_album(entry: pg_core::library::Album, proton: bool) -> GalleryAlbum {
fn gallery_album(entry: proton_gallery_rs::library::Album, proton: bool) -> GalleryAlbum {
GalleryAlbum {
place: GalleryPlace {
gallery: entry.gallery.to_string(),
@@ -444,7 +447,7 @@ impl Core {
"Use your Linux sign-in to unlock Hidden albums.",
));
}
let subject = pg_app::desktop_auth::Subject::new(
let subject = proton_gallery_app_rs::desktop_auth::Subject::new(
peer.pid.as_raw_nonzero().get() as u32,
peer.uid.as_raw(),
)
+2 -2
View File
@@ -11,8 +11,8 @@ use hyper::{
};
use hyper_util::rt::TokioIo;
use pdfs_core::{CoreResult, control::Response as ControlResponse};
use pg_app::video::VideoStream;
use pg_core::CancellationToken;
use proton_gallery_app_rs::video::VideoStream;
use proton_gallery_rs::CancellationToken;
use tokio::net::TcpListener;
type Body = UnsyncBoxBody<Bytes, io::Error>;
+8 -76
View File
@@ -212,15 +212,12 @@ impl BlockRing {
}
/// The result of fetching one block, shared between everyone who wanted it.
type BlockResult = Result<Arc<Vec<u8>>, Errno>;
pub(super) type BlockResult = Result<Arc<Vec<u8>>, Errno>;
/// Identifies a block *of a revision*: node, validity tag, and the plaintext
/// range the block covers — see [`RingKey`] for why it is the range and not the
/// index.
type BlockKey = (NodeUid, i64, u64, BlockSpan);
/// A claim on a block key: who owns the fetch, and where its result is published.
type Claim = (u64, tokio::sync::watch::Receiver<Option<BlockResult>>);
pub(super) type BlockKey = (NodeUid, i64, u64, BlockSpan);
/// Block fetches in flight, so a block is downloaded and decrypted once however
/// many readers want it at that moment (audit T1).
@@ -231,34 +228,7 @@ type Claim = (u64, tokio::sync::watch::Receiver<Option<BlockResult>>);
/// for. Without this each of them pays the full round-trip and decrypt and all
/// but one result is discarded — roughly double the bandwidth and CPU in steady
/// state. Same shape as [`ReaderSlot::Pending`] one level up.
#[derive(Default)]
pub(super) struct BlockFlight {
inflight: Mutex<HashMap<BlockKey, Claim>>,
}
/// Distinguishes attempts at the same key, so a leader only retires its own.
static NEXT_FLIGHT_ID: AtomicU64 = AtomicU64::new(0);
/// The leader's claim on a key. Retires it on drop — including when the task is
/// cancelled mid-fetch, which is what keeps a dropped `JoinSet` from leaving a
/// key nobody will ever publish.
struct Flight {
flight: Arc<BlockFlight>,
key: BlockKey,
id: u64,
}
impl Drop for Flight {
fn drop(&mut self) {
let mut inflight = self.flight.inflight.lock();
if inflight
.get(&self.key)
.is_some_and(|(id, _)| *id == self.id)
{
inflight.remove(&self.key);
}
}
}
pub(super) type BlockFlight = proton_media_rs::SingleFlight<BlockKey, BlockResult>;
/// Where each file's reader is expected to read next, so sequential reads can be
/// told from random ones and only the former prefetched (audit T2).
@@ -581,49 +551,11 @@ impl Core {
cache_blocks: bool,
) -> BlockResult {
let key: BlockKey = (uid.clone(), mtime, fsize, span);
let claim = {
let mut inflight = self.block_flight.inflight.lock();
match inflight.get(&key) {
Some((_, rx)) => Err(rx.clone()),
None => {
let id = NEXT_FLIGHT_ID.fetch_add(1, Ordering::Relaxed);
let (tx, rx) = tokio::sync::watch::channel(None);
inflight.insert(key.clone(), (id, rx));
Ok((
tx,
Flight {
flight: self.block_flight.clone(),
key: key.clone(),
id,
},
))
}
}
};
let (tx, flight) = match claim {
Ok(lead) => lead,
Err(mut rx) => {
loop {
if let Some(result) = rx.borrow_and_update().clone() {
return result;
}
if rx.changed().await.is_err() {
break;
}
}
return self
.read_block(reader, uid, mtime, fsize, span, cache_blocks)
.await;
}
};
let result = self
.read_block(reader, uid, mtime, fsize, span, cache_blocks)
.await;
// Retire the claim before publishing, so a racer that wakes and re-enters
// finds no stale entry to join.
drop(flight);
let _ = tx.send(Some(result.clone()));
result
self.block_flight
.join(key, || {
self.read_block(reader, uid, mtime, fsize, span, cache_blocks)
})
.await
}
/// Download and decrypt one block, then put it where the next reader will
+1 -1
View File
@@ -527,7 +527,7 @@ impl Core {
let scan = match scan_archives_until(archives, || self.import_should_stop(cancel)) {
Ok(scan) => scan,
Err(_) if self.import_should_stop(cancel) => return Ok(true),
Err(e) => return Err(e),
Err(e) => return Err(CoreError::conflict(e.to_string())),
};
*planned = plan(&scan);
*albums = scan.albums.clone();
+1 -1
View File
@@ -22,7 +22,7 @@ name = "pdfs-prompt"
path = "src/prompt.rs"
[dependencies]
pg-core.workspace = true
proton-gallery-rs.workspace = true
base64.workspace = true
pdfs-core.workspace = true
tracing.workspace = true
+6
View File
@@ -336,6 +336,9 @@ pub(crate) fn login_error_message(error: &pdfs_core::Error) -> String {
pdfs_core::Error::WrongMailboxPassword => {
gettext("That mailbox password didn't unlock your account.")
}
pdfs_core::Error::SecurityKeyOnly => gettext(
"This account's only second factor is a security key, which this app can't use yet. Add an authenticator app in your Proton account settings, then sign in with its code.",
),
pdfs_core::Error::Other(message) if message.contains("verification") => gettext(
"Sign-in cancelled: the verification wasn't completed. Sign in again to get a new one.",
),
@@ -711,6 +714,9 @@ mod tests {
#[test]
fn a_cancelled_prompt_says_which_step_was_skipped() {
assert!(
login_error_message(&pdfs_core::Error::SecurityKeyOnly).contains("authenticator app")
);
let totp = pdfs_core::Error::Other("two-factor entry cancelled".into());
assert!(login_error_message(&totp).contains("two-factor code"));
let hv = pdfs_core::Error::Other("verification cancelled".into());
+2 -2
View File
@@ -2360,7 +2360,7 @@ const TILE_RATIO_MAX: f64 = 2.5;
/// The shape a photo's tile takes: its own, clamped, or square while the
/// daemon has not seen a thumbnail of it yet.
pub(crate) fn tile_ratio(ratio: Option<f64>) -> f64 {
pg_core::grid::tile_ratio(ratio.unwrap_or(1.0))
proton_gallery_rs::grid::tile_ratio(ratio.unwrap_or(1.0))
}
/// The justified layout math: tiles of the given shapes, in order, broken into
@@ -2373,7 +2373,7 @@ pub(crate) fn tile_ratio(ratio: Option<f64>) -> f64 {
/// two photos from one day stay two photos at the target height, not two
/// photos as tall as the window.
pub(crate) fn plan_justified(ratios: &[f64], width: i32, target: i32) -> Vec<Vec<(i32, i32)>> {
let Ok(grid) = pg_core::grid::plan_sections(
let Ok(grid) = proton_gallery_rs::grid::plan_sections(
ratios,
&[],
width.clamp(1, 32_768) as u32,
+1 -1
View File
@@ -432,7 +432,7 @@ the build Fedora 45 and 46 ship as stable, from before oo7's
[7fb11dd](https://github.com/linux-credentials/oo7/commit/7fb11dd111c4be8fec01996e3caa31c44fa962b3)
("server: Write item changes to the keyring file"). See
[the investigation](ISSUE-78.md#setsecret-is-kept-only-in-memory-in-fedoras-oo7).
**Where:** `crates/pdfs-core/src/auth.rs`, `write_stored`; `crates/pdfs-core/src/secretservice.rs`
**Where:** `crates/pdfs-core/src/auth.rs`, `write_stored`; `proton-auth-rs` (`secret_service.rs`, moved from `crates/pdfs-core/src/secretservice.rs`)
**Repro:** With oo7-daemon at e91b98a, save the session blob, save it again with a new refresh
token, and restart oo7-daemon. The read after the restart returns the first blob. The keyring
+24
View File
@@ -11,6 +11,30 @@ scratch (user data in `staging/` and `recovery/` is never touched by this).
## [Unreleased]
### Changed
- Signing in runs through `proton_auth_rs::session`, the sequence Proton Gallery and
Proton Stream use too. The stored session, the lock/unlock choice for two-password
accounts, the three mailbox-password tries and the messages stay as they were.
- An account whose only second factor is a security key now gets a clear message at
sign-in instead of a code prompt that could only fail.
- Block fetches shared by concurrent readers now use `SingleFlight` from
`proton-media-rs`, the same code Proton Stream uses. Same behaviour: one
download per block, every reader gets its result, and a reader whose fetch was
cancelled downloads the block itself.
- The shared Gallery engine now comes from the `proton-gallery-rs` and
`proton-gallery-app-rs` crates on crates.io instead of a pinned Git revision of
Proton Gallery. Builds, vendoring and the Nix package no longer fetch from Git.
- RAW+JPEG grouping, Google Takeout reading, EXIF capture times, look-alike
detection and the offline town lookup now come from `proton-gallery-rs`,
shared with Proton Gallery. No behaviour change.
- The keyring code (one Secret Service connection that reconnects after the provider
restarts, B285, and replacing the session item instead of editing it, B291) now comes
from `proton-auth-rs`, shared with Proton Gallery and Proton Stream. No behaviour change.
- Config, machine-id and mount-failure files are written through `proton-base-rs`'s
atomic writer (temporary file, sync, rename, directory sync). The mount-failure file
is now synced before the rename too, so a crash cannot leave it empty.
## [3.9.0] — 2026-11-19
Schema: **46**. Photos adds a local database migration for incremental metadata sync.
+1 -4
View File
@@ -46,10 +46,7 @@ rustPlatform.buildRustPackage {
];
};
cargoLock = {
lockFile = ../../Cargo.lock;
allowBuiltinFetchGit = true;
};
cargoLock.lockFile = ../../Cargo.lock;
cargoBuildFlags = [
"--bin"
+4
View File
@@ -3599,6 +3599,10 @@ msgstr "Anmeldung abgebrochen: Es wurde kein Postfach-Passwort eingegeben."
msgid "That mailbox password didn't unlock your account."
msgstr "Das Postfach-Passwort hat Ihr Konto nicht entsperrt."
#: crates/pdfs-gui/src/app/pages/login.rs
msgid "This account's only second factor is a security key, which this app can't use yet. Add an authenticator app in your Proton account settings, then sign in with its code."
msgstr "Der einzige zweite Faktor dieses Kontos ist ein Sicherheitsschlüssel, den diese App noch nicht nutzen kann. Fügen Sie in Ihren Proton-Kontoeinstellungen eine Authentifizierungs-App hinzu und melden Sie sich dann mit deren Code an."
#: crates/pdfs-gui/src/app/pages/login.rs:340
msgid ""
"Sign-in cancelled: the verification wasn't completed. Sign in again to get a "
+4
View File
@@ -3541,6 +3541,10 @@ msgstr "Sign-in cancelled: no mailbox password was entered."
msgid "That mailbox password didn't unlock your account."
msgstr "That mailbox password didn't unlock your account."
#: crates/pdfs-gui/src/app/pages/login.rs
msgid "This account's only second factor is a security key, which this app can't use yet. Add an authenticator app in your Proton account settings, then sign in with its code."
msgstr "This account's only second factor is a security key, which this app can't use yet. Add an authenticator app in your Proton account settings, then sign in with its code."
#: crates/pdfs-gui/src/app/pages/login.rs:340
msgid ""
"Sign-in cancelled: the verification wasn't completed. Sign in again to get a "
+4
View File
@@ -3575,6 +3575,10 @@ msgstr "Inicio de sesión cancelado: no se introdujo la contraseña del buzón."
msgid "That mailbox password didn't unlock your account."
msgstr "Esa contraseña del buzón no desbloqueó tu cuenta."
#: crates/pdfs-gui/src/app/pages/login.rs
msgid "This account's only second factor is a security key, which this app can't use yet. Add an authenticator app in your Proton account settings, then sign in with its code."
msgstr "El único segundo factor de esta cuenta es una llave de seguridad, que esta aplicación aún no puede usar. Añade una aplicación de autenticación en los ajustes de tu cuenta de Proton y luego inicia sesión con su código."
#: crates/pdfs-gui/src/app/pages/login.rs:340
msgid ""
"Sign-in cancelled: the verification wasn't completed. Sign in again to get a "
+4
View File
@@ -3600,6 +3600,10 @@ msgid "That mailbox password didn't unlock your account."
msgstr ""
"Ce mot de passe de boîte aux lettres n’a pas déverrouillé votre compte."
#: crates/pdfs-gui/src/app/pages/login.rs
msgid "This account's only second factor is a security key, which this app can't use yet. Add an authenticator app in your Proton account settings, then sign in with its code."
msgstr "Le seul second facteur de ce compte est une clé de sécurité, que cette application ne peut pas encore utiliser. Ajoutez une application d’authentification dans les paramètres de votre compte Proton, puis connectez-vous avec son code."
#: crates/pdfs-gui/src/app/pages/login.rs:340
msgid ""
"Sign-in cancelled: the verification wasn't completed. Sign in again to get a "
+4
View File
@@ -3593,6 +3593,10 @@ msgid "That mailbox password didn't unlock your account."
msgstr ""
"Quella password della casella di posta non ha sbloccato il tuo account."
#: crates/pdfs-gui/src/app/pages/login.rs
msgid "This account's only second factor is a security key, which this app can't use yet. Add an authenticator app in your Proton account settings, then sign in with its code."
msgstr "L’unico secondo fattore di questo account è una chiave di sicurezza, che questa app non può ancora usare. Aggiungi un’app di autenticazione nelle impostazioni del tuo account Proton, poi accedi con il suo codice."
#: crates/pdfs-gui/src/app/pages/login.rs:340
msgid ""
"Sign-in cancelled: the verification wasn't completed. Sign in again to get a "
+4
View File
@@ -3583,6 +3583,10 @@ msgstr "Aanmelden geannuleerd: er is geen mailboxwachtwoord ingevoerd."
msgid "That mailbox password didn't unlock your account."
msgstr "Dat mailboxwachtwoord heeft je account niet ontgrendeld."
#: crates/pdfs-gui/src/app/pages/login.rs
msgid "This account's only second factor is a security key, which this app can't use yet. Add an authenticator app in your Proton account settings, then sign in with its code."
msgstr "De enige tweede factor van dit account is een beveiligingssleutel, die deze app nog niet kan gebruiken. Voeg een authenticator-app toe in je Proton-accountinstellingen en meld je daarna aan met de code daarvan."
#: crates/pdfs-gui/src/app/pages/login.rs:340
msgid ""
"Sign-in cancelled: the verification wasn't completed. Sign in again to get a "
+4
View File
@@ -3411,6 +3411,10 @@ msgstr ""
msgid "That mailbox password didn't unlock your account."
msgstr ""
#: crates/pdfs-gui/src/app/pages/login.rs
msgid "This account's only second factor is a security key, which this app can't use yet. Add an authenticator app in your Proton account settings, then sign in with its code."
msgstr ""
#: crates/pdfs-gui/src/app/pages/login.rs:340
msgid ""
"Sign-in cancelled: the verification wasn't completed. Sign in again to get a "
+4
View File
@@ -3652,6 +3652,10 @@ msgstr "Anulowano logowanie: nie wpisano hasła skrzynki pocztowej."
msgid "That mailbox password didn't unlock your account."
msgstr "To hasło skrzynki pocztowej nie odblokowało Twojego konta."
#: crates/pdfs-gui/src/app/pages/login.rs
msgid "This account's only second factor is a security key, which this app can't use yet. Add an authenticator app in your Proton account settings, then sign in with its code."
msgstr "Jedynym drugim składnikiem tego konta jest klucz bezpieczeństwa, którego ta aplikacja nie może jeszcze używać. Dodaj aplikację uwierzytelniającą w ustawieniach konta Proton, a następnie zaloguj się jej kodem."
#: crates/pdfs-gui/src/app/pages/login.rs:340
msgid ""
"Sign-in cancelled: the verification wasn't completed. Sign in again to get a "
+4
View File
@@ -3575,6 +3575,10 @@ msgstr "Entrada cancelada: nenhuma senha da caixa de correio foi digitada."
msgid "That mailbox password didn't unlock your account."
msgstr "Essa senha da caixa de correio não desbloqueou sua conta."
#: crates/pdfs-gui/src/app/pages/login.rs
msgid "This account's only second factor is a security key, which this app can't use yet. Add an authenticator app in your Proton account settings, then sign in with its code."
msgstr "O único segundo fator desta conta é uma chave de segurança, que este app ainda não pode usar. Adicione um app autenticador nas configurações da sua conta Proton e depois entre com o código dele."
#: crates/pdfs-gui/src/app/pages/login.rs:340
msgid ""
"Sign-in cancelled: the verification wasn't completed. Sign in again to get a "