Skip to main content

wechat_protocol/
large_file.rs

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
7// The reference sends the current 128-block group and at most its two preceding
8// groups. This uploader is sequential: only blocks before `next_block` have a
9// verified acknowledgement. Offsets and alreadyupsize remain file-relative.
10fn 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    /// Upload one ordinary file using previously persisted source/key material.
22    /// Object readback and business-message submission remain separate operations.
23    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    /// [`Self::upload_large_file_with_progress`] for an upload read from a
43    /// file in steps. The requests are the same; the block that ends the
44    /// object is sent only after the whole file matched its digests.
45    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    /// Upload the unmodified original as a separate type-4 object. The normal
65    /// rendition and thumbnail use their own paired upload and final metadata.
66    /// Persist the task ID and prepared material before calling this method.
67    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    /// [`Self::upload_video_original_with_progress`] for an original read from
83    /// a file in steps.
84    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    // No automatic retries: a failed request leaves the caller's persisted
229    // source/key material intact and never submits a business message.
230    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    // Each block is produced just before it is sent. For a file, the block
299    // that ends the object is produced only once the whole source matched its
300    // prepared digests, so a changed source never reaches `fin`.
301    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    // Return the correlated completion even if cancellation arrived while this
345    // request was in flight. The caller persists it before checking its fence.
346    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    // The fixtures below hold their uploads in memory.
355    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    // This peer accepts only the captured four-phase wire contract. It checks
465    // offsets, encrypted block hashes, prior acknowledgements and both tokens.
466    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        // The peer checks every block against the in-memory ciphertext.
634        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        // Changed after preparation: every block but the last is sent, then the
648        // transfer stops before `fin`.
649        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}