librespot_core/
audio_key.rs

1use std::{collections::HashMap, io::Write, time::Duration};
2
3use byteorder::{BigEndian, ByteOrder, WriteBytesExt};
4use bytes::Bytes;
5use thiserror::Error;
6use tokio::sync::oneshot;
7
8use crate::{Error, FileId, SpotifyId, packet::PacketType, util::SeqGenerator};
9
10#[derive(Debug, Hash, PartialEq, Eq, Copy, Clone)]
11pub struct AudioKey(pub [u8; 16]);
12
13#[derive(Debug, Error)]
14pub enum AudioKeyError {
15    #[error("audio key error")]
16    AesKey,
17    #[error("other end of channel disconnected")]
18    Channel,
19    #[error("unexpected packet type {0}")]
20    Packet(u8),
21    #[error("sequence {0} not pending")]
22    Sequence(u32),
23    #[error("audio key response timeout")]
24    Timeout,
25}
26
27impl From<AudioKeyError> for Error {
28    fn from(err: AudioKeyError) -> Self {
29        match err {
30            AudioKeyError::AesKey => Error::unavailable(err),
31            AudioKeyError::Channel => Error::aborted(err),
32            AudioKeyError::Sequence(_) => Error::aborted(err),
33            AudioKeyError::Packet(_) => Error::unimplemented(err),
34            AudioKeyError::Timeout => Error::aborted(err),
35        }
36    }
37}
38
39component! {
40    AudioKeyManager : AudioKeyManagerInner {
41        sequence: SeqGenerator<u32> = SeqGenerator::new(0),
42        pending: HashMap<u32, oneshot::Sender<Result<AudioKey, Error>>> = HashMap::new(),
43    }
44}
45
46impl AudioKeyManager {
47    pub(crate) fn dispatch(&self, cmd: PacketType, mut data: Bytes) -> Result<(), Error> {
48        let seq = BigEndian::read_u32(data.split_to(4).as_ref());
49
50        let sender = self
51            .lock(|inner| inner.pending.remove(&seq))
52            .ok_or(AudioKeyError::Sequence(seq))?;
53
54        match cmd {
55            PacketType::AesKey => {
56                let mut key = [0u8; 16];
57                key.copy_from_slice(data.as_ref());
58                sender
59                    .send(Ok(AudioKey(key)))
60                    .map_err(|_| AudioKeyError::Channel)?
61            }
62            PacketType::AesKeyError => {
63                error!(
64                    "error audio key {:x} {:x}",
65                    data.as_ref()[0],
66                    data.as_ref()[1]
67                );
68                sender
69                    .send(Err(AudioKeyError::AesKey.into()))
70                    .map_err(|_| AudioKeyError::Channel)?
71            }
72            _ => {
73                trace!("Did not expect {cmd:?} AES key packet with data {data:#?}");
74                return Err(AudioKeyError::Packet(cmd as u8).into());
75            }
76        }
77
78        Ok(())
79    }
80
81    pub async fn request(&self, track: SpotifyId, file: FileId) -> Result<AudioKey, Error> {
82        let (tx, rx) = oneshot::channel();
83
84        let seq = self.lock(move |inner| {
85            let seq = inner.sequence.get();
86            inner.pending.insert(seq, tx);
87            seq
88        });
89
90        self.send_key_request(seq, track, file)?;
91        const KEY_RESPONSE_TIMEOUT: Duration = Duration::from_millis(1500);
92        match tokio::time::timeout(KEY_RESPONSE_TIMEOUT, rx).await {
93            Err(_) => {
94                error!("Audio key response timeout");
95                Err(AudioKeyError::Timeout.into())
96            }
97            Ok(k) => k?,
98        }
99    }
100
101    fn send_key_request(&self, seq: u32, track: SpotifyId, file: FileId) -> Result<(), Error> {
102        let mut data: Vec<u8> = Vec::new();
103        data.write_all(&file.0)?;
104        data.write_all(&track.to_raw())?;
105        data.write_u32::<BigEndian>(seq)?;
106        data.write_u16::<BigEndian>(0x0000)?;
107
108        self.session().send_packet(PacketType::RequestKey, data)
109    }
110}
librespot_core/audio_key.rs

librespot_core/
audio_key.rs
