1use super::*;
2
3const MAX_UPLOAD_TOKEN_BYTES: usize = 65536;
4const BLOCKS_PER_GROUP: usize = 128;
5const MAX_BLOCKS: usize = (MAX_LARGE_FILE_BYTES + 16).div_ceil(512 * 1024);
6
7fn acknowledged_bitmap(next_block: usize) -> Vec<u8> {
11 let group = next_block / BLOCKS_PER_GROUP;
12 let first_group = group.saturating_sub(2);
13 let mut bitmap = vec![0; (group - first_group + 1) * 16];
14 for bit in 0..next_block - first_group * BLOCKS_PER_GROUP {
15 bitmap[bit / 8] |= 1 << (bit % 8);
16 }
17 bitmap
18}
19
20impl CdnClient {
21 pub fn upload_large_file_with_progress(
24 &self,
25 prepared: &PreparedUpload,
26 task_id: u64,
27 progress: impl FnMut(u64, Option<u64>) -> Result<()>,
28 ) -> Result<UploadedMedia> {
29 ensure!(
30 matches!(prepared.kind, MediaQuality::File | MediaQuality::LargeFile),
31 "Expected an ordinary file upload"
32 );
33 upload_large_file(
34 &self.config,
35 UploadRef::Memory(prepared),
36 task_id,
37 |path, fields| self.post(path, fields),
38 progress,
39 )
40 }
41
42 pub fn upload_large_file_from_file_with_progress(
46 &self,
47 prepared: &PreparedFileUpload,
48 task_id: u64,
49 progress: impl FnMut(u64, Option<u64>) -> Result<()>,
50 ) -> Result<UploadedMedia> {
51 ensure!(
52 matches!(prepared.kind, MediaQuality::File | MediaQuality::LargeFile),
53 "Expected an ordinary file upload"
54 );
55 upload_large_file(
56 &self.config,
57 UploadRef::File(prepared),
58 task_id,
59 |path, fields| self.post(path, fields),
60 progress,
61 )
62 }
63
64 pub fn upload_video_original_with_progress(
68 &self,
69 prepared: &PreparedUpload,
70 task_id: u64,
71 progress: impl FnMut(u64, Option<u64>) -> Result<()>,
72 ) -> Result<UploadedMedia> {
73 upload_video_original(
74 self,
75 UploadRef::Memory(prepared),
76 task_id,
77 |path, fields| self.post(path, fields),
78 progress,
79 )
80 }
81
82 pub fn upload_video_original_from_file_with_progress(
85 &self,
86 prepared: &PreparedFileUpload,
87 task_id: u64,
88 progress: impl FnMut(u64, Option<u64>) -> Result<()>,
89 ) -> Result<UploadedMedia> {
90 upload_video_original(
91 self,
92 UploadRef::File(prepared),
93 task_id,
94 |path, fields| self.post(path, fields),
95 progress,
96 )
97 }
98}
99
100fn upload_video_original(
101 client: &CdnClient,
102 prepared: UploadRef<'_>,
103 task_id: u64,
104 post: impl FnMut(&str, &CdnFields) -> Result<CdnFields>,
105 progress: impl FnMut(u64, Option<u64>) -> Result<()>,
106) -> Result<UploadedMedia> {
107 ensure!(
108 prepared.kind() == MediaQuality::Video && task_id != 0,
109 "Expected an original video upload and task ID"
110 );
111 prepared.validate()?;
112 if prepared.encrypted_len() < MAX_CDN_TRANSFER_BYTES {
113 client.upload_with_transport(prepared, progress, post)
114 } else {
115 upload_large_file(&client.config, prepared, task_id, post, progress)
116 }
117}
118
119fn common_fields(
120 conf: &CdnConfig,
121 prepared: UploadRef<'_>,
122 task_id: u64,
123 sequence: u32,
124) -> CdnFields {
125 let mut fields = CdnFields::new();
126 for (key, value) in [
127 ("ver", conf.version as u64),
128 ("seq", sequence as u64),
129 ("weixinnum", conf.uin),
130 ("nettype", 1),
131 ("ipseq", 0),
132 ("retrycnt", 0),
133 ("lastretcode", 0),
134 ("waitsec", 0),
135 ("clientversion", conf.client_version as u64),
136 ("taskid", task_id),
137 ("from", 0),
138 ("bizid", 1),
139 ("appid", 0),
140 ("filetype", u64::from(prepared.kind().filetype())),
141 ("optype", 0),
142 ("expectbizid", 0),
143 ("expectappid", 0),
144 ("expectfiletype", u64::from(prepared.kind().filetype())),
145 ("expectoptype", 0),
146 ("frontid", conf.front_id as u64),
147 ] {
148 put(&mut fields, key, value);
149 }
150 fields.insert("authkey".into(), conf.auth_key.clone());
151 fields.insert(
152 "clientostype".into(),
153 conf.client_os_type.as_bytes().to_vec(),
154 );
155 fields.insert("filekey".into(), prepared.file_key().as_bytes().to_vec());
156 if let Some(location) = conf.location {
157 for (key, value) in [
158 ("province", location.province),
159 ("city", location.city),
160 ("isp", location.isp),
161 ] {
162 put(&mut fields, key, value);
163 }
164 }
165 fields
166}
167
168fn validate_reply(reply: &CdnFields, sequence: u32, version: u32) -> Result<()> {
169 ensure!(
170 integer(reply, "seq")? == i64::from(sequence),
171 "Large-file reply sequence mismatch"
172 );
173 let code = integer(reply, "retcode")?;
174 ServiceRejected::check_wide(Service::LargeFileUpload, code)?;
175 for key in ["isretry", "retrysec", "isoverload", "isgetcdn"] {
176 ensure!(
177 integer(reply, key)? == 0,
178 "Unsupported large-file upload retry or routing control"
179 );
180 }
181 ensure!(
182 integer(reply, "ver")? == i64::from(version),
183 "Large-file reply version mismatch"
184 );
185 Ok(())
186}
187
188fn opaque_field(reply: &CdnFields, key: &str, max_bytes: usize) -> Result<Vec<u8>> {
189 let value = reply
190 .get(key)
191 .ok_or_else(|| anyhow::anyhow!("Missing large-file {key}"))?;
192 ensure!(
193 !value.is_empty() && value.len() <= max_bytes,
194 "Invalid large-file {key} length"
195 );
196 Ok(value.clone())
197}
198
199fn upload_large_file(
200 conf: &CdnConfig,
201 prepared: UploadRef<'_>,
202 task_id: u64,
203 mut post: impl FnMut(&str, &CdnFields) -> Result<CdnFields>,
204 mut progress: impl FnMut(u64, Option<u64>) -> Result<()>,
205) -> Result<UploadedMedia> {
206 ensure!(
207 ((prepared.kind() == MediaQuality::File
208 && prepared.plaintext_bytes() as usize > MAX_NATIVE_UPLOAD_BYTES
209 && prepared.plaintext_bytes() as usize <= MAX_CDN_TRANSFER_BYTES)
210 || (prepared.kind() == MediaQuality::LargeFile
211 && prepared.plaintext_bytes() as usize > MAX_CDN_TRANSFER_BYTES
212 && prepared.plaintext_bytes() as usize <= MAX_LARGE_FILE_BYTES)
213 || (prepared.kind() == MediaQuality::Video
214 && prepared.plaintext_bytes() as usize > MAX_NATIVE_UPLOAD_BYTES
215 && prepared.plaintext_bytes() as usize <= wechat_media::MAX_VIDEO_SOURCE_BYTES))
216 && prepared.encrypted_len() >= MAX_CDN_TRANSFER_BYTES
217 && task_id != 0,
218 "Unsupported large-file upload profile"
219 );
220 conf.validate()?;
221 ensure!(
222 conf.location.is_some(),
223 "Missing authenticated CDN location"
224 );
225 prepared.validate()?;
226 let total = prepared.encrypted_len() as u64;
227 let mut sequence = 0u32;
228 let mut exchange =
231 |phase: &str,
232 extra: CdnFields,
233 acknowledged: u64,
234 progress: &mut dyn FnMut(u64, Option<u64>) -> Result<()>| {
235 progress(acknowledged, Some(total))?;
236 sequence += 1;
237 let mut fields = common_fields(conf, prepared, task_id, sequence);
238 fields.extend(extra);
239 let path = format!(
240 "/cdn/{}/{sequence}/{}/{phase}",
241 conf.uin,
242 prepared.kind().filetype()
243 );
244 let reply = post(&path, &fields)?;
245 validate_reply(&reply, sequence, conf.version)?;
246 Ok::<_, anyhow::Error>(reply)
247 };
248
249 let mut apply = CdnFields::new();
250 for (key, value) in [
251 ("apptype", 1),
252 ("chatnum", 1),
253 ("reqtype", 0),
254 ("type", u64::from(prepared.kind().filetype())),
255 ("prepare", 0),
256 ("num", 1),
257 ("type_0", u64::from(prepared.kind().filetype())),
258 ("cpr_0", 0),
259 ("size_0", total),
260 ("rawsize_0", prepared.plaintext_bytes() as u64),
261 ("format_0", 0),
262 ] {
263 put(&mut apply, key, value);
264 }
265 apply.insert(
266 "chatid".into(),
267 encrypt_recipient(prepared.destination())?.into_bytes(),
268 );
269 apply.insert("rawfilemd5_0".into(), prepared.md5().as_bytes().to_vec());
270 if let Some((_, extension)) = prepared.file_name().rsplit_once('.') {
271 if !extension.is_empty() {
272 apply.insert("ext_0".into(), extension.as_bytes().to_vec());
273 }
274 }
275 let reply = exchange("apply", apply, 0, &mut progress)?;
276 ensure!(
277 integer(&reply, "hit")? == 0,
278 "Large-file cache hits require unsupported key recovery"
279 );
280 ensure!(
281 integer(&reply, "type")? == i64::from(prepared.kind().filetype())
282 && integer(&reply, "num")? == 1
283 && integer(&reply, "type_0")? == i64::from(prepared.kind().filetype())
284 && integer(&reply, "fin_0")? == 0,
285 "Unsupported large-file apply result"
286 );
287 let block_size = usize::try_from(integer(&reply, "blocksize_0")?)?;
288 ensure!(
289 [512 * 1024, 1024 * 1024].contains(&block_size)
290 && prepared.encrypted_len().div_ceil(block_size) <= MAX_BLOCKS,
291 "Unsupported large-file block size"
292 );
293 let upinfo = opaque_field(&reply, "upinfo_0", MAX_UPLOAD_TOKEN_BYTES)?;
294 progress(0, Some(total))?;
295
296 let mut acknowledged = 0u64;
297 let mut etags = Vec::new();
298 let mut chunks = prepared.chunks();
302 let mut index = 0usize;
303 while (chunks.position() as u64) < total {
304 let chunk = chunks.next(block_size)?;
305 let mut fields = CdnFields::new();
306 put(&mut fields, "alreadyupsize", acknowledged);
307 fields.insert("alreadyupbit".into(), acknowledged_bitmap(index));
308 fields.insert("upinfo".into(), upinfo.clone());
309 put(&mut fields, "offset", acknowledged);
310 fields.insert("blockmd5".into(), hex::encode(md5(&chunk)).into_bytes());
311 fields.insert("blockdata".into(), chunk.to_vec());
312 let reply = exchange("uploadblock", fields, acknowledged, &mut progress)?;
313 ensure!(
314 u64::try_from(integer(&reply, "offset")?)? == acknowledged
315 && integer(&reply, "fin")? == 0,
316 "Large-file block acknowledgement mismatch"
317 );
318 etags.push(opaque_field(&reply, "etag", 8192)?);
319 acknowledged += chunk.len() as u64;
320 index += 1;
321 progress(acknowledged, Some(total))?;
322 }
323 ensure!(acknowledged == total, "Incomplete large-file upload");
324
325 let mut finish = CdnFields::new();
326 finish.insert("upinfo".into(), upinfo);
327 put(&mut finish, "blocksum", etags.len());
328 for (index, etag) in etags.into_iter().enumerate() {
329 finish.insert(format!("etag_{index}"), etag);
330 }
331 let reply = exchange("fin", finish, acknowledged, &mut progress)?;
332 let finished_upinfo = opaque_field(&reply, "upinfo", MAX_UPLOAD_TOKEN_BYTES)?;
333 progress(acknowledged, Some(total))?;
334 let mut complete = CdnFields::new();
335 put(&mut complete, "type", prepared.kind().filetype());
336 put(&mut complete, "num", 1);
337 complete.insert("upinfo_0".into(), finished_upinfo);
338 let reply = exchange("complete", complete, acknowledged, &mut progress)?;
339 let file_id = String::from_utf8(opaque_field(&reply, "fileid", 8192)?)?;
340 ensure!(
341 !file_id.chars().any(|c| c.is_control()),
342 "Invalid large-file identifier"
343 );
344 Ok(prepared.uploaded(file_id, None, None))
347}
348
349#[cfg(test)]
350mod tests {
351 use super::*;
352 use std::{cell::RefCell, sync::OnceLock};
353
354 fn upload_large_file(
356 conf: &CdnConfig,
357 prepared: &PreparedUpload,
358 task_id: u64,
359 post: impl FnMut(&str, &CdnFields) -> Result<CdnFields>,
360 progress: impl FnMut(u64, Option<u64>) -> Result<()>,
361 ) -> Result<UploadedMedia> {
362 super::upload_large_file(conf, UploadRef::Memory(prepared), task_id, post, progress)
363 }
364 fn upload_video_original(
365 client: &CdnClient,
366 prepared: &PreparedUpload,
367 task_id: u64,
368 post: impl FnMut(&str, &CdnFields) -> Result<CdnFields>,
369 progress: impl FnMut(u64, Option<u64>) -> Result<()>,
370 ) -> Result<UploadedMedia> {
371 super::upload_video_original(client, UploadRef::Memory(prepared), task_id, post, progress)
372 }
373
374 #[test]
375 fn acknowledgement_windows_cross_multiple_groups_without_wrapping() {
376 assert_eq!(acknowledged_bitmap(0), vec![0; 16]);
377 let mut before_boundary = vec![255; 16];
378 before_boundary[15] = 127;
379 assert_eq!(acknowledged_bitmap(127), before_boundary);
380 assert_eq!(
381 acknowledged_bitmap(128),
382 [vec![255; 16], vec![0; 16]].concat()
383 );
384 assert_eq!(
385 acknowledged_bitmap(256),
386 [vec![255; 32], vec![0; 16]].concat()
387 );
388 for index in [384, 512, 1024] {
389 assert_eq!(
390 acknowledged_bitmap(index),
391 [vec![255; 32], vec![0; 16]].concat()
392 );
393 }
394 let mut after_boundary = [vec![255; 32], vec![0; 16]].concat();
395 after_boundary[32] = 1;
396 assert_eq!(acknowledged_bitmap(513), after_boundary);
397 assert_eq!(MAX_BLOCKS, 1025);
398 }
399
400 #[test]
401 fn final_request_serializes_all_maximum_file_etags_in_order() {
402 let mut fields = CdnFields::new();
403 put(&mut fields, "blocksum", MAX_BLOCKS);
404 fields.insert("upinfo".into(), b"synthetic-finish-context".to_vec());
405 for index in 0..MAX_BLOCKS {
406 fields.insert(
407 format!("etag_{index}"),
408 format!("synthetic-{index}").into_bytes(),
409 );
410 }
411 let wire = pack_cdn(&fields).unwrap();
412 let mut cursor = crate::mmtls::Cursor::new(&wire);
413 let mut decoded = CdnFields::new();
414 for _ in 0..MAX_BLOCKS + 2 {
415 let key = std::str::from_utf8(cursor.sized(4).unwrap())
416 .unwrap()
417 .to_owned();
418 decoded.insert(key, cursor.sized(4).unwrap().to_vec());
419 }
420 cursor.end().unwrap();
421 assert_eq!(integer(&decoded, "blocksum").unwrap(), 1025);
422 for index in 0..MAX_BLOCKS {
423 assert_eq!(
424 decoded[&format!("etag_{index}")],
425 format!("synthetic-{index}").as_bytes()
426 );
427 }
428 fields.extend((MAX_BLOCKS..2048).map(|i| (format!("etag_{i}"), vec![1])));
429 assert!(pack_cdn(&fields).is_err());
430 }
431
432 fn config() -> CdnConfig {
433 CdnConfig {
434 version: 1,
435 uin: 12345,
436 client_version: 456,
437 client_os_type: "test-client".into(),
438 auth_key: b"test-credential".to_vec(),
439 server_ips: vec![Ipv4Addr::new(1, 1, 1, 1)],
440 front_id: 789,
441 location: Some(CdnLocation {
442 province: 1234,
443 city: 56,
444 isp: 78,
445 }),
446 }
447 }
448
449 fn prepared() -> &'static PreparedUpload {
450 static VALUE: OnceLock<PreparedUpload> = OnceLock::new();
451 VALUE.get_or_init(|| {
452 PreparedUpload::with_material(
453 &vec![0x5a; MAX_CDN_TRANSFER_BYTES + 17],
454 MediaQuality::LargeFile,
455 "boundary.fixture.bin",
456 "filehelper",
457 &[0x31; 16],
458 "00112233445566778899aabbccddeeff",
459 )
460 .unwrap()
461 })
462 }
463
464 struct Peer<'a> {
467 prepared: &'a PreparedUpload,
468 block_size: usize,
469 requests: usize,
470 }
471
472 impl<'a> Peer<'a> {
473 fn new(prepared: &'a PreparedUpload, block_size: usize) -> Self {
474 Self {
475 prepared,
476 block_size,
477 requests: 0,
478 }
479 }
480
481 fn blocks(&self) -> usize {
482 self.prepared.encrypted.len().div_ceil(self.block_size)
483 }
484
485 fn respond(&mut self, path: &str, fields: &CdnFields) -> Result<CdnFields> {
486 self.requests += 1;
487 let sequence = self.requests;
488 let kind = self.prepared.kind.filetype();
489 let phase = match sequence {
490 1 => "apply",
491 n if n <= self.blocks() + 1 => "uploadblock",
492 n if n == self.blocks() + 2 => "fin",
493 n if n == self.blocks() + 3 => "complete",
494 _ => panic!("Request after completion"),
495 };
496 assert_eq!(path, format!("/cdn/12345/{sequence}/{kind}/{phase}"));
497 assert_eq!(integer(fields, "seq")?, sequence as i64);
498 assert_eq!(integer(fields, "taskid")?, 987654321);
499 assert_eq!(integer(fields, "filetype")?, i64::from(kind));
500 assert_eq!(integer(fields, "expectfiletype")?, i64::from(kind));
501 assert_eq!(integer(fields, "frontid")?, 789);
502 for key in ["ipseq", "retrycnt", "lastretcode", "waitsec"] {
503 assert_eq!(integer(fields, key)?, 0);
504 }
505 assert_eq!(integer(fields, "province")?, 1234);
506 assert_eq!(integer(fields, "city")?, 56);
507 assert_eq!(integer(fields, "isp")?, 78);
508 assert_eq!(fields["authkey"], b"test-credential");
509 assert_eq!(fields["filekey"], self.prepared.file_key.as_bytes());
510 assert!(!fields.contains_key("aeskey"));
511 assert!(!fields.contains_key("signature"));
512 let mut reply = CdnFields::new();
513 for (key, value) in [
514 ("ver", 1),
515 ("seq", sequence),
516 ("retcode", 0),
517 ("isretry", 0),
518 ("retrysec", 0),
519 ("isoverload", 0),
520 ("isgetcdn", 0),
521 ] {
522 put(&mut reply, key, value);
523 }
524 match phase {
525 "apply" => {
526 assert_eq!(integer(fields, "type")?, i64::from(kind));
527 assert_eq!(integer(fields, "type_0")?, i64::from(kind));
528 assert_eq!(integer(fields, "num")?, 1);
529 assert_eq!(integer(fields, "apptype")?, 1);
530 assert_eq!(integer(fields, "chatnum")?, 1);
531 assert_eq!(
532 integer(fields, "size_0")?,
533 self.prepared.encrypted.len() as i64
534 );
535 assert_eq!(
536 integer(fields, "rawsize_0")?,
537 i64::from(self.prepared.plaintext_bytes)
538 );
539 assert_eq!(fields["rawfilemd5_0"], self.prepared.md5.as_bytes());
540 assert_eq!(
541 fields["ext_0"],
542 self.prepared
543 .file_name
544 .rsplit('.')
545 .next()
546 .unwrap()
547 .as_bytes()
548 );
549 assert_eq!(
550 fields["chatid"],
551 encrypt_recipient("filehelper")?.as_bytes()
552 );
553 for (key, value) in [
554 ("hit", 0),
555 ("type", kind as usize),
556 ("num", 1),
557 ("type_0", kind as usize),
558 ("fin_0", 0),
559 ("blocksize_0", self.block_size),
560 ] {
561 put(&mut reply, key, value);
562 }
563 reply.insert("upinfo_0".into(), b"apply-token".to_vec());
564 }
565 "uploadblock" => {
566 let index = sequence - 2;
567 let offset = index * self.block_size;
568 let end = (offset + self.block_size).min(self.prepared.encrypted.len());
569 let expected = &self.prepared.encrypted[offset..end];
570 assert_eq!(integer(fields, "offset")?, offset as i64);
571 assert_eq!(integer(fields, "alreadyupsize")?, offset as i64);
572 assert_eq!(fields["upinfo"], b"apply-token");
573 assert_eq!(fields["blockdata"], expected);
574 assert_eq!(fields["blockmd5"], hex::encode(md5(expected)).as_bytes());
575 let bitmap: Vec<u8> = (0..128)
576 .collect::<Vec<_>>()
577 .chunks(8)
578 .map(|bits| {
579 bits.iter().fold(0, |value, bit| {
580 value | (u8::from(*bit < index) << (bit % 8))
581 })
582 })
583 .collect();
584 assert_eq!(fields["alreadyupbit"], bitmap);
585 put(&mut reply, "offset", offset);
586 put(&mut reply, "fin", 0);
587 reply.insert("etag".into(), format!("etag-{index}").into_bytes());
588 }
589 "fin" => {
590 assert_eq!(fields["upinfo"], b"apply-token");
591 assert_eq!(integer(fields, "blocksum")?, self.blocks() as i64);
592 for index in 0..self.blocks() {
593 assert_eq!(
594 fields[&format!("etag_{index}")],
595 format!("etag-{index}").as_bytes()
596 );
597 }
598 reply.insert("upinfo".into(), b"finish-token".to_vec());
599 }
600 "complete" => {
601 assert_eq!(integer(fields, "type")?, i64::from(kind));
602 assert_eq!(integer(fields, "num")?, 1);
603 assert_eq!(fields["upinfo_0"], b"finish-token");
604 reply.insert("fileid".into(), b"completed-object".to_vec());
605 }
606 _ => unreachable!(),
607 }
608 Ok(reply)
609 }
610 }
611
612 #[test]
613 fn a_file_source_sends_the_same_blocks_and_a_changed_file_never_finishes() {
614 let memory = prepared();
615 let raw = vec![0x5a; MAX_CDN_TRANSFER_BYTES + 17];
616 let directory = wechat_platform::private_tempdir("wechat-large-file-test-").unwrap();
617 let path = directory.path().join("source");
618 std::fs::write(&path, &raw).unwrap();
619 let open = || {
620 PreparedFileUpload::new(
621 std::fs::File::open(&path).unwrap(),
622 raw.len() as u64,
623 &memory.md5,
624 &memory.sha256,
625 memory.kind,
626 &memory.file_name,
627 &memory.destination,
628 &memory.aes_key,
629 &memory.file_key,
630 )
631 .unwrap()
632 };
633 let file = open();
635 let mut peer = Peer::new(memory, 512 * 1024);
636 let result = super::upload_large_file(
637 &config(),
638 UploadRef::File(&file),
639 987654321,
640 |path, fields| peer.respond(path, fields),
641 |_, _| Ok(()),
642 )
643 .unwrap();
644 assert_eq!(peer.requests, peer.blocks() + 3);
645 assert_eq!(result.descriptor.file_id, "completed-object");
646 assert_eq!(result.sha256, memory.sha256);
647 let mut changed = raw.clone();
650 let last = changed.len() - 1;
651 changed[last] ^= 1;
652 std::fs::write(&path, &changed).unwrap();
653 let file = open();
654 let mut peer = Peer::new(memory, 512 * 1024);
655 let mut phases = vec![];
656 let error = super::upload_large_file(
657 &config(),
658 UploadRef::File(&file),
659 987654321,
660 |path, fields| {
661 phases.push(path.rsplit('/').next().unwrap().to_string());
662 peer.respond(path, fields)
663 },
664 |_, _| Ok(()),
665 )
666 .err()
667 .unwrap();
668 assert_eq!(error.to_string(), "Prepared upload digest mismatch");
669 assert!(!phases
670 .iter()
671 .any(|phase| phase == "fin" || phase == "complete"));
672 assert_eq!(
673 phases
674 .iter()
675 .filter(|phase| *phase == "uploadblock")
676 .count(),
677 peer.blocks() - 1
678 );
679 }
680
681 #[test]
682 fn transfers_ordered_blocks_and_uses_finish_token() {
683 let prepared = prepared();
684 for block_size in [512 * 1024, 1024 * 1024] {
685 let mut peer = Peer::new(prepared, block_size);
686 let events = RefCell::new(Vec::new());
687 let progress = RefCell::new(Vec::new());
688 let result = upload_large_file(
689 &config(),
690 prepared,
691 987654321,
692 |path, fields| {
693 events.borrow_mut().push("request");
694 peer.respond(path, fields)
695 },
696 |done, total| {
697 events.borrow_mut().push("progress");
698 progress.borrow_mut().push(done);
699 assert_eq!(total, Some(prepared.encrypted.len() as u64));
700 Ok(())
701 },
702 )
703 .unwrap();
704 assert_eq!(peer.requests, peer.blocks() + 3);
705 let events = events.borrow();
706 for event in events[..events.len() - 2].chunks(3) {
707 assert_eq!(event, ["progress", "request", "progress"]);
708 }
709 assert_eq!(&events[events.len() - 2..], ["progress", "request"]);
710 let positions = progress.borrow();
711 assert!(positions.windows(2).all(|pair| pair[0] <= pair[1]));
712 assert_eq!(
713 positions.last().copied(),
714 Some(prepared.encrypted.len() as u64)
715 );
716 assert_eq!(result.descriptor.file_id, "completed-object");
717 assert_eq!(result.descriptor.quality, MediaQuality::LargeFile);
718 assert_eq!(
719 result.descriptor.expected_bytes,
720 Some(prepared.plaintext_bytes as u64)
721 );
722 assert_eq!(result.descriptor.aes_key, prepared.aes_key);
723 assert_eq!(result.md5, prepared.md5);
724 assert_eq!(result.sha256, prepared.sha256);
725 }
726 }
727
728 #[test]
729 fn standalone_original_video_uses_type_four_without_thumbnail() {
730 let mut raw = prepared().clone();
731 raw.kind = MediaQuality::Video;
732 raw.file_name = "original.mp4".into();
733 let cdn = CdnClient::new(config(), Duration::from_secs(1)).unwrap();
734 let cancelled = std::cell::Cell::new(false);
735 let mut peer = Peer::new(&raw, 1024 * 1024);
736 let result = upload_video_original(
737 &cdn,
738 &raw,
739 987654321,
740 |path, fields| {
741 assert!(!fields.contains_key("thumbdata"));
742 assert!(!fields.contains_key("type_1"));
743 let response = peer.respond(path, fields)?;
744 if path.ends_with("/complete") {
745 cancelled.set(true);
746 }
747 Ok(response)
748 },
749 |_, _| {
750 ensure!(!cancelled.get(), "cancelled");
751 Ok(())
752 },
753 )
754 .unwrap();
755 assert!(cancelled.get());
756 assert_eq!(result.descriptor.quality, MediaQuality::Video);
757 assert_eq!(
758 result.descriptor.expected_bytes,
759 Some(u64::from(raw.plaintext_bytes))
760 );
761 assert_eq!(result.descriptor.aes_key, raw.aes_key);
762 assert_eq!(result.md5, raw.md5);
763 assert_eq!(result.sha256, raw.sha256);
764 assert_eq!(peer.requests, peer.blocks() + 3);
765 assert!(cdn
766 .upload_large_file_with_progress(&raw, 987654321, |_, _| {
767 panic!("Video admitted by ordinary-file interface")
768 })
769 .is_err());
770 }
771
772 #[test]
773 fn small_original_video_uses_standalone_legacy_and_rejects_bad_material_locally() {
774 let raw = PreparedUpload::with_material(
775 b"\0\0\0\x0cftypisom",
776 MediaQuality::Video,
777 "original.mp4",
778 "filehelper",
779 &[0x31; 16],
780 "00112233445566778899aabbccddeeff",
781 )
782 .unwrap();
783 let cdn = CdnClient::new(config(), Duration::from_secs(1)).unwrap();
784 let mut calls = 0;
785 let result = upload_video_original(
786 &cdn,
787 &raw,
788 987654321,
789 |path, fields| {
790 calls += 1;
791 assert_eq!(path, "/uploadv3");
792 assert_eq!(integer(fields, "filetype")?, 4);
793 assert!(!fields.contains_key("thumbdata"));
794 assert_eq!(integer(fields, "hasthumb")?, 0);
795 let mut reply = CdnFields::new();
796 put(&mut reply, "retcode", 0);
797 for key in ["seq", "rangestart", "rangeend"] {
798 reply.insert(key.into(), fields[key].clone());
799 }
800 reply.insert("fileid".into(), b"small-original".to_vec());
801 Ok(reply)
802 },
803 |_, _| Ok(()),
804 )
805 .unwrap();
806 assert_eq!(calls, 1);
807 assert_eq!(result.descriptor.quality, MediaQuality::Video);
808 let mut over = raw.clone();
809 over.plaintext_bytes = wechat_media::MAX_VIDEO_SOURCE_BYTES as u32 + 1;
810 let mut wrong = raw.clone();
811 wrong.kind = MediaQuality::File;
812 let mut corrupt = raw.clone();
813 corrupt.encrypted[0] ^= 1;
814 for (value, task) in [
815 (&over, 987654321),
816 (&wrong, 987654321),
817 (&corrupt, 987654321),
818 (&raw, 0),
819 ] {
820 assert!(upload_video_original(
821 &cdn,
822 value,
823 task,
824 |_, _| { panic!("Invalid original video reached transport") },
825 |_, _| Ok(())
826 )
827 .is_err());
828 }
829 }
830
831 #[test]
832 fn original_video_padding_boundary_selects_one_carrier_without_fallback() {
833 let cdn = CdnClient::new(config(), Duration::from_secs(1)).unwrap();
834 for (size, expected_path) in [
835 (MAX_NATIVE_UPLOAD_BYTES, "/uploadv3"),
836 (MAX_NATIVE_UPLOAD_BYTES + 1, "/cdn/12345/1/4/apply"),
837 ] {
838 let raw = PreparedUpload::with_material(
839 &vec![0x5a; size],
840 MediaQuality::Video,
841 "original.mp4",
842 "filehelper",
843 &[0x31; 16],
844 "00112233445566778899aabbccddeeff",
845 )
846 .unwrap();
847 let mut calls = 0;
848 let error = upload_video_original(
849 &cdn,
850 &raw,
851 987654321,
852 |path, fields| {
853 calls += 1;
854 assert_eq!(path, expected_path);
855 assert_eq!(integer(fields, "filetype")?, 4);
856 bail!("isolated transport failure")
857 },
858 |_, _| Ok(()),
859 )
860 .err()
861 .unwrap();
862 assert_eq!(error.to_string(), "isolated transport failure");
863 assert_eq!(calls, 1);
864 }
865 }
866
867 #[test]
868 fn padding_band_and_exact_threshold_keep_filetype_five() {
869 for (plaintext, ciphertext, requests) in [
870 (MAX_CDN_TRANSFER_BYTES - 16, MAX_CDN_TRANSFER_BYTES, 28),
871 (MAX_CDN_TRANSFER_BYTES - 1, MAX_CDN_TRANSFER_BYTES, 28),
872 (MAX_CDN_TRANSFER_BYTES, MAX_CDN_TRANSFER_BYTES + 16, 29),
873 ] {
874 let prepared = PreparedUpload::with_material(
875 &vec![0x5a; plaintext],
876 MediaQuality::File,
877 "boundary.fixture.bin",
878 "filehelper",
879 &[0x31; 16],
880 "00112233445566778899aabbccddeeff",
881 )
882 .unwrap();
883 assert_eq!(prepared.encrypted.len(), ciphertext);
884 let legacy = CdnClient::new(config(), Duration::from_secs(1)).unwrap();
885 let rejected = legacy.upload_with_progress(&prepared, |_, _| {
886 panic!("Legacy transfer started for a multiphase file")
887 });
888 assert_eq!(
889 rejected.err().unwrap().to_string(),
890 "File requires multiphase upload"
891 );
892 let mut peer = Peer::new(&prepared, 1024 * 1024);
893 let result = upload_large_file(
894 &config(),
895 &prepared,
896 987654321,
897 |path, fields| peer.respond(path, fields),
898 |_, _| Ok(()),
899 )
900 .unwrap();
901 assert_eq!(result.descriptor.quality, MediaQuality::File);
902 assert_eq!(peer.requests, requests);
903 }
904 }
905
906 #[test]
907 fn completed_object_receipt_survives_late_cancellation() {
908 let cancelled = std::cell::Cell::new(false);
909 let mut peer = Peer::new(prepared(), 1024 * 1024);
910 let uploaded = upload_large_file(
911 &config(),
912 prepared(),
913 987654321,
914 |path, fields| {
915 let reply = peer.respond(path, fields)?;
916 if path.ends_with("/complete") {
917 cancelled.set(true);
918 }
919 Ok(reply)
920 },
921 |_, _| {
922 ensure!(!cancelled.get(), "cancelled");
923 Ok(())
924 },
925 )
926 .unwrap();
927 assert!(cancelled.get());
928 assert_eq!(uploaded.descriptor.file_id, "completed-object");
929 assert_eq!(peer.requests, peer.blocks() + 3);
930 }
931
932 #[test]
933 fn rejects_apply_changes_and_cache_hits_without_sending_blocks() {
934 for (key, value) in [
935 ("seq", 2),
936 ("ver", 2),
937 ("retcode", -1),
938 ("isretry", 1),
939 ("retrysec", 1),
940 ("isoverload", 1),
941 ("isgetcdn", 1),
942 ("hit", 1),
943 ("type_0", 5),
944 ("num", 2),
945 ("fin_0", 1),
946 ("blocksize_0", 2 * 1024 * 1024),
947 ("blocksize_0", -1),
948 ] {
949 let mut peer = Peer::new(prepared(), 1024 * 1024);
950 let result = upload_large_file(
951 &config(),
952 prepared(),
953 987654321,
954 |path, fields| {
955 let mut reply = peer.respond(path, fields)?;
956 put(&mut reply, key, value);
957 Ok(reply)
958 },
959 |_, _| Ok(()),
960 );
961 assert!(result.is_err(), "Accepted invalid {key}");
962 assert_eq!(peer.requests, 1);
963 }
964 }
965
966 #[test]
967 fn rejected_reply_preserves_server_code_without_trusting_wrong_sequence() {
968 let mut reply = CdnFields::new();
969 put(&mut reply, "seq", 1);
970 put(&mut reply, "ver", 0);
971 put(&mut reply, "retcode", -5103015);
972 assert_eq!(
973 validate_reply(&reply, 1, 1).unwrap_err().to_string(),
974 "Large-file upload returned -5103015"
975 );
976 put(&mut reply, "seq", 2);
977 assert_eq!(
978 validate_reply(&reply, 1, 1).unwrap_err().to_string(),
979 "Large-file reply sequence mismatch"
980 );
981 put(&mut reply, "seq", 1);
982 put(&mut reply, "retcode", 0);
983 for key in ["isretry", "retrysec", "isoverload", "isgetcdn"] {
984 put(&mut reply, key, 0);
985 }
986 assert_eq!(
987 validate_reply(&reply, 1, 1).unwrap_err().to_string(),
988 "Large-file reply version mismatch"
989 );
990 put(&mut reply, "isretry", 1);
991 assert_eq!(
992 validate_reply(&reply, 1, 1).unwrap_err().to_string(),
993 "Unsupported large-file upload retry or routing control"
994 );
995 put(&mut reply, "isretry", 0);
996 put(&mut reply, "ver", 1);
997 validate_reply(&reply, 1, 1).unwrap();
998 }
999
1000 #[test]
1001 fn missing_authenticated_location_stops_before_any_exchange() {
1002 let mut conf = config();
1003 conf.location = None;
1004 let mut requests = 0;
1005 let result = upload_large_file(
1006 &conf,
1007 prepared(),
1008 987654321,
1009 |_, _| {
1010 requests += 1;
1011 bail!("unexpected request")
1012 },
1013 |_, _| Ok(()),
1014 );
1015 assert_eq!(
1016 result.err().unwrap().to_string(),
1017 "Missing authenticated CDN location"
1018 );
1019 assert_eq!(requests, 0);
1020 }
1021
1022 #[test]
1023 fn rejects_conflicting_or_incomplete_block_acknowledgement() {
1024 for bad in ["offset", "fin", "etag", "seq"] {
1025 let mut peer = Peer::new(prepared(), 1024 * 1024);
1026 let result = upload_large_file(
1027 &config(),
1028 prepared(),
1029 987654321,
1030 |path, fields| {
1031 let mut reply = peer.respond(path, fields)?;
1032 if path.ends_with("/uploadblock") {
1033 if bad == "etag" {
1034 reply.remove("etag");
1035 } else {
1036 put(&mut reply, bad, 1);
1037 }
1038 }
1039 Ok(reply)
1040 },
1041 |_, _| Ok(()),
1042 );
1043 assert!(result.is_err(), "Accepted invalid {bad}");
1044 assert_eq!(peer.requests, 2);
1045 }
1046 }
1047
1048 #[test]
1049 fn cancellation_before_request_or_after_ack_never_continues() {
1050 for cancel_at in [1, 2, 3, 4, 5, 6] {
1051 let mut peer = Peer::new(prepared(), 1024 * 1024);
1052 let mut callbacks = 0;
1053 let result = upload_large_file(
1054 &config(),
1055 prepared(),
1056 987654321,
1057 |path, fields| peer.respond(path, fields),
1058 |_, _| {
1059 callbacks += 1;
1060 ensure!(callbacks != cancel_at, "cancelled");
1061 Ok(())
1062 },
1063 );
1064 assert!(result.is_err());
1065 assert_eq!(callbacks, cancel_at);
1066 assert_eq!(peer.requests, cancel_at / 2);
1067 }
1068 }
1069
1070 #[test]
1071 fn transport_failure_is_not_retried_and_missing_completion_is_not_success() {
1072 let mut requests = 0;
1073 assert!(upload_large_file(
1074 &config(),
1075 prepared(),
1076 987654321,
1077 |_, _| {
1078 requests += 1;
1079 bail!("transport failed")
1080 },
1081 |_, _| Ok(())
1082 )
1083 .is_err());
1084 assert_eq!(requests, 1);
1085 for phase in ["fin", "complete"] {
1086 let mut peer = Peer::new(prepared(), 1024 * 1024);
1087 let result = upload_large_file(
1088 &config(),
1089 prepared(),
1090 987654321,
1091 |path, fields| {
1092 let mut reply = peer.respond(path, fields)?;
1093 if path.ends_with(&format!("/{phase}")) {
1094 reply.remove(if phase == "fin" { "upinfo" } else { "fileid" });
1095 }
1096 Ok(reply)
1097 },
1098 |_, _| Ok(()),
1099 );
1100 assert!(result.is_err());
1101 assert_eq!(
1102 peer.requests,
1103 peer.blocks() + if phase == "fin" { 2 } else { 3 }
1104 );
1105 }
1106 }
1107
1108 #[test]
1109 fn invalid_persisted_material_and_task_are_rejected_before_network() {
1110 let mut altered = prepared().clone();
1111 altered.encrypted[0] ^= 1;
1112 let small = PreparedUpload::with_material(
1113 b"small control",
1114 MediaQuality::File,
1115 "small.bin",
1116 "filehelper",
1117 &[0x31; 16],
1118 "00112233445566778899aabbccddeeff",
1119 )
1120 .unwrap();
1121 let mut requests = 0;
1122 for (prepared, task) in [(&altered, 987654321), (&small, 987654321), (prepared(), 0)] {
1123 assert!(upload_large_file(
1124 &config(),
1125 prepared,
1126 task,
1127 |_, _| {
1128 requests += 1;
1129 bail!("must not reach transport")
1130 },
1131 |_, _| Ok(())
1132 )
1133 .is_err());
1134 }
1135 assert_eq!(requests, 0);
1136 }
1137}