github-mirrors/librespot
1
0
Fork 0
mirror of https://github.com/librespot-org/librespot.git synced 2024-12-18 17:11:53 +00:00
Code Issues Projects Releases Packages Wiki Activity

rustfmt: core

Browse source
This commit is contained in:
awiouy 2018-02-11 12:37:08 +01:00
parent 0d92ac74d1
commit c9ba73c9ef
21 changed files with 290 additions and 249 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

19
core/build.rs
View file

@ -1,36 +1,35 @@
extern crate vergen;
extern crate protobuf_macros;
extern crate rand;
extern crate vergen;
use rand::Rng;
use std::env;
use std::path::PathBuf;
use std::fs::OpenOptions;
use std::io::Write;
use std::path::PathBuf;
fn main() {
let out = PathBuf::from(env::var("OUT_DIR").unwrap());
vergen::vergen(vergen::OutputFns::all()).unwrap();
let build_id: String = rand::thread_rng()
.gen_ascii_chars()
.take(8)
.collect();
let build_id: String = rand::thread_rng().gen_ascii_chars().take(8).collect();
let mut version_file =
OpenOptions::new()
let mut version_file = OpenOptions::new()
.write(true)
.append(true)
.open(&out.join("version.rs"))
.unwrap();
let build_id_fn = format!("
let build_id_fn = format!(
"
/// Generate a random build id.
pub fn build_id() -> &'static str {{
\"{}\"
}}
", build_id);
",
build_id
);
if let Err(e) = version_file.write_all(build_id_fn.as_bytes()) {
println!("{}", e);

23
core/src/apresolve.rs
View file

@ -1,17 +1,17 @@
const AP_FALLBACK: &'static str = "ap.spotify.com:80";
const APRESOLVE_ENDPOINT: &'static str = "http://apresolve.spotify.com/";
use std::str::FromStr;
use futures::{Future, Stream};
use hyper::{self, Uri, Client};
use hyper::{self, Client, Uri};
use serde_json;
use std::str::FromStr;
use tokio_core::reactor::Handle;
error_chain!{}
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct APResolveData {
ap_list: Vec<String>
ap_list: Vec<String>,
}
fn apresolve(handle: &Handle) -> Box<Future<Item = String, Error = Error>> {
@ -27,14 +27,10 @@ fn apresolve(handle: &Handle) -> Box<Future<Item=String, Error=Error>> {
})
});
let body = body.then(|result| result.chain_err(|| "HTTP error"));
let body = body.and_then(|body| {
String::from_utf8(body).chain_err(|| "invalid UTF8 in response")
});
let body = body.and_then(|body| String::from_utf8(body).chain_err(|| "invalid UTF8 in response"));
let data = body.and_then(|body| {
serde_json::from_str::<APResolveData>(&body)
.chain_err(|| "invalid JSON")
});
let data =
body.and_then(|body| serde_json::from_str::<APResolveData>(&body).chain_err(|| "invalid JSON"));
let ap = data.and_then(|data| {
let ap = data.ap_list.first().ok_or("empty AP List")?;
@ -44,9 +40,10 @@ fn apresolve(handle: &Handle) -> Box<Future<Item=String, Error=Error>> {
Box::new(ap)
}
pub(crate) fn apresolve_or_fallback<E>(handle: &Handle)
-> Box<Future<Item=String, Error=E>>
where E: 'static {
pub(crate) fn apresolve_or_fallback<E>(handle: &Handle) -> Box<Future<Item = String, Error = E>>
where
E: 'static,
{
let ap = apresolve(handle).or_else(|e| {
warn!("Failed to resolve Access Point: {}", e.description());
warn!("Using fallback \"{}\"", AP_FALLBACK);

11
core/src/audio_key.rs
View file

@ -1,12 +1,12 @@
use byteorder::{BigEndian, ByteOrder, WriteBytesExt};
use bytes::Bytes;
use futures::sync::oneshot;
use futures::{Async, Future, Poll};
use futures::sync::oneshot;
use std::collections::HashMap;
use std::io::Write;
use util::{FileId, SpotifyId};
use util::SeqGenerator;
use util::{SpotifyId, FileId};
#[derive(Debug, Hash, PartialEq, Eq, Copy, Clone)]
pub struct AudioKey(pub [u8; 16]);
@ -35,7 +35,11 @@ impl AudioKeyManager {
let _ = sender.send(Ok(AudioKey(key)));
}
0xe => {
warn!("error audio key {:x} {:x}", data.as_ref()[0], data.as_ref()[1]);
warn!(
"error audio key {:x} {:x}",
data.as_ref()[0],
data.as_ref()[1]
);
let _ = sender.send(Err(AudioKeyError));
}
_ => (),
@ -81,4 +85,3 @@ impl <T> Future for AudioKeyFuture<T> {
}
}
}

64
core/src/authentication.rs
View file

@ -10,14 +10,13 @@ use protobuf::ProtobufEnum;
use rpassword;
use serde;
use serde_json;
use std::io::{self, stderr, Read, Write};
use std::fs::File;
use std::io::{self, stderr, Read, Write};
use std::path::Path;
use protocol::authentication::AuthenticationType;
#[derive(Debug, Clone)]
#[derive(Serialize, Deserialize)]
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Credentials {
pub username: String,
@ -89,12 +88,17 @@ impl Credentials {
let blob = {
// Anyone know what this block mode is ?
let mut data = vec![0u8; encrypted_blob.len()];
let mut cipher = aes::ecb_decryptor(aes::KeySize::KeySize192,
let mut cipher = aes::ecb_decryptor(
aes::KeySize::KeySize192,
&key,
crypto::blockmodes::NoPadding);
cipher.decrypt(&mut crypto::buffer::RefReadBuffer::new(&encrypted_blob),
crypto::blockmodes::NoPadding,
);
cipher
.decrypt(
&mut crypto::buffer::RefReadBuffer::new(&encrypted_blob),
&mut crypto::buffer::RefWriteBuffer::new(&mut data),
true)
true,
)
.unwrap();
let l = encrypted_blob.len();
@ -112,7 +116,7 @@ impl Credentials {
let auth_type = read_int(&mut cursor).unwrap();
let auth_type = AuthenticationType::from_i32(auth_type as i32).unwrap();
read_u8(&mut cursor).unwrap();
let auth_data = read_bytes(&mut cursor).unwrap();;
let auth_data = read_bytes(&mut cursor).unwrap();
Credentials {
username: username,
@ -144,42 +148,49 @@ impl Credentials {
}
fn serialize_protobuf_enum<T, S>(v: &T, ser: S) -> Result<S::Ok, S::Error>
where T: ProtobufEnum, S: serde::Serializer {
where
T: ProtobufEnum,
S: serde::Serializer,
{
serde::Serialize::serialize(&v.value(), ser)
}
fn deserialize_protobuf_enum<T, D>(de: D) -> Result<T, D::Error>
where T: ProtobufEnum, D: serde::Deserializer {
where
T: ProtobufEnum,
D: serde::Deserializer,
{
let v: i32 = try!(serde::Deserialize::deserialize(de));
T::from_i32(v).ok_or_else(|| serde::de::Error::custom("Invalid enum value"))
}
fn serialize_base64<T, S>(v: &T, ser: S) -> Result<S::Ok, S::Error>
where T: AsRef<[u8]>, S: serde::Serializer {
where
T: AsRef<[u8]>,
S: serde::Serializer,
{
serde::Serialize::serialize(&base64::encode(v.as_ref()), ser)
}
fn deserialize_base64<D>(de: D) -> Result<Vec<u8>, D::Error>
where D: serde::Deserializer {
where
D: serde::Deserializer,
{
let v: String = try!(serde::Deserialize::deserialize(de));
base64::decode(&v).map_err(|e| serde::de::Error::custom(e.to_string()))
}
pub fn get_credentials(username: Option<String>, password: Option<String>,
cached_credentials: Option<Credentials>)
-> Option<Credentials>
{
pub fn get_credentials(
username: Option<String>,
password: Option<String>,
cached_credentials: Option<Credentials>,
) -> Option<Credentials> {
match (username, password, cached_credentials) {
(Some(username), Some(password), _) => Some(Credentials::with_password(username, password)),
(Some(username), Some(password), _)
=> Some(Credentials::with_password(username, password)),
(Some(ref username), _, Some(ref credentials))
if *username == credentials.username => Some(credentials.clone()),
(Some(ref username), _, Some(ref credentials)) if *username == credentials.username => {
Some(credentials.clone())
}
(Some(username), None, _) => {
write!(stderr(), "Password for {}: ", username).unwrap();
@ -188,8 +199,7 @@ pub fn get_credentials(username: Option<String>, password: Option<String>,
Some(Credentials::with_password(username.clone(), password))
}
(None, _, Some(credentials))
=> Some(credentials),
(None, _, Some(credentials)) => Some(credentials),
(None, _, None) => None,
}

4
core/src/cache.rs
View file

@ -5,8 +5,8 @@ use std::io::Read;
use std::path::Path;
use std::path::PathBuf;
use util::FileId;
use authentication::Credentials;
use util::FileId;
#[derive(Clone)]
pub struct Cache {
@ -31,7 +31,7 @@ impl Cache {
Cache {
root: location,
use_audio_cache: use_audio_cache
use_audio_cache: use_audio_cache,
}
}
}

4
core/src/channel.rs
View file

@ -1,7 +1,7 @@
use byteorder::{BigEndian, ByteOrder};
use bytes::Bytes;
use futures::sync::{BiLock, mpsc};
use futures::{Poll, Async, Stream};
use futures::{Async, Poll, Stream};
use futures::sync::{mpsc, BiLock};
use std::collections::HashMap;
use util::SeqGenerator;

2
core/src/component.rs
View file

@ -36,8 +36,8 @@ macro_rules! component {
}
}
use std::sync::Mutex;
use std::cell::UnsafeCell;
use std::sync::Mutex;
pub struct Lazy<T>(Mutex<bool>, UnsafeCell<Option<T>>);
unsafe impl<T: Sync> Sync for Lazy<T> {}

5
core/src/config.rs
View file

@ -1,6 +1,6 @@
use uuid::Uuid;
use std::str::FromStr;
use std::fmt;
use std::str::FromStr;
use uuid::Uuid;
use version;
@ -20,7 +20,6 @@ impl Default for SessionConfig {
}
}
#[derive(Clone, Copy, Debug, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub enum Bitrate {
Bitrate96,

6
core/src/connection/codec.rs
View file

@ -1,5 +1,5 @@
use byteorder::{BigEndian, ByteOrder};
use bytes::{Bytes, BytesMut, BufMut};
use bytes::{BufMut, Bytes, BytesMut};
use shannon::Shannon;
use std::io;
use tokio_io::codec::{Decoder, Encoder};
@ -88,7 +88,8 @@ impl Decoder for APCodec {
let mut payload = buf.split_to(size + MAC_SIZE);
self.decode_cipher.decrypt(&mut payload.get_mut(..size).unwrap());
self.decode_cipher
.decrypt(&mut payload.get_mut(..size).unwrap());
let mac = payload.split_off(size);
self.decode_cipher.check_mac(mac.as_ref())?;
@ -96,7 +97,6 @@ impl Decoder for APCodec {
}
}
Ok(None)
}
}

41
core/src/connection/handshake.rs
View file

@ -1,20 +1,21 @@
use crypto::sha1::Sha1;
use byteorder::{BigEndian, ByteOrder, WriteBytesExt};
use crypto::hmac::Hmac;
use crypto::mac::Mac;use byteorder::{BigEndian, ByteOrder, WriteBytesExt};
use crypto::mac::Mac;
use crypto::sha1::Sha1;
use futures::{Async, Future, Poll};
use protobuf::{self, Message, MessageStatic};
use rand::thread_rng;
use std::io::{self, Read};
use std::marker::PhantomData;
use tokio_io::{AsyncRead, AsyncWrite};
use tokio_io::codec::Framed;
use tokio_io::io::{write_all, WriteAll, read_exact, ReadExact, Window};
use futures::{Poll, Async, Future};
use tokio_io::io::{read_exact, write_all, ReadExact, Window, WriteAll};
use super::codec::APCodec;
use diffie_hellman::DHLocalKeys;
use protocol;
use protocol::keyexchange::{ClientHello, APResponseMessage, ClientResponsePlaintext};
use protocol::keyexchange::{APResponseMessage, ClientHello, ClientResponsePlaintext};
use util;
use super::codec::APCodec;
pub struct Handshake<T> {
keys: DHLocalKeys,
@ -54,15 +55,15 @@ impl <T: AsyncRead + AsyncWrite> Future for Handshake<T> {
APResponse(ref mut read) => {
let (connection, message, accumulator) = try_ready!(read.poll());
let remote_key = message.get_challenge()
let remote_key = message
.get_challenge()
.get_login_crypto_challenge()
.get_diffie_hellman()
.get_gs()
.to_owned();
let shared_secret = self.keys.shared_secret(&remote_key);
let (challenge, send_key, recv_key) = compute_keys(&shared_secret,
&accumulator);
let (challenge, send_key, recv_key) = compute_keys(&shared_secret, &accumulator);
let codec = APCodec::new(&send_key, &recv_key);
let write = client_response(connection, challenge);
@ -129,15 +130,17 @@ enum RecvPacket<T, M: MessageStatic> {
}
fn recv_packet<T: AsyncRead, M>(connection: T, acc: Vec<u8>) -> RecvPacket<T, M>
where T: Read,
M: MessageStatic
where
T: Read,
M: MessageStatic,
{
RecvPacket::Header(read_into_accumulator(connection, 4, acc), PhantomData)
}
impl<T: AsyncRead, M> Future for RecvPacket<T, M>
where T: Read,
M: MessageStatic
where
T: Read,
M: MessageStatic,
{
type Item = (T, M, Vec<u8>);
type Error = io::Error;
@ -167,7 +170,11 @@ impl <T: AsyncRead, M> Future for RecvPacket<T, M>
}
}
fn read_into_accumulator<T: AsyncRead>(connection: T, size: usize, mut acc: Vec<u8>) -> ReadExact<T, Window<Vec<u8>>> {
fn read_into_accumulator<T: AsyncRead>(
connection: T,
size: usize,
mut acc: Vec<u8>,
) -> ReadExact<T, Window<Vec<u8>>> {
let offset = acc.len();
acc.resize(offset + size, 0);
@ -191,5 +198,9 @@ fn compute_keys(shared_secret: &[u8], packets: &[u8]) -> (Vec<u8>, Vec<u8>, Vec<
mac = Hmac::new(Sha1::new(), &data[..0x14]);
mac.input(packets);
(mac.result().code().to_vec(), data[0x14..0x34].to_vec(), data[0x34..0x54].to_vec())
(
mac.result().code().to_vec(),
data[0x14..0x34].to_vec(),
data[0x34..0x54].to_vec(),
)
}

35
core/src/connection/mod.rs
View file

@ -5,31 +5,34 @@ pub use self::codec::APCodec;
pub use self::handshake::handshake;
use futures::{Future, Sink, Stream};
use protobuf::{self, Message};
use std::io;
use std::net::ToSocketAddrs;
use tokio_core::net::TcpStream;
use tokio_core::reactor::Handle;
use tokio_io::codec::Framed;
use protobuf::{self, Message};
use authentication::Credentials;
use version;
pub type Transport = Framed<TcpStream, APCodec>;
pub fn connect<A: ToSocketAddrs>(addr: A, handle: &Handle) -> Box<Future<Item = Transport, Error = io::Error>> {
pub fn connect<A: ToSocketAddrs>(
addr: A,
handle: &Handle,
) -> Box<Future<Item = Transport, Error = io::Error>> {
let addr = addr.to_socket_addrs().unwrap().next().unwrap();
let socket = TcpStream::connect(&addr, handle);
let connection = socket.and_then(|socket| {
handshake(socket)
});
let connection = socket.and_then(|socket| handshake(socket));
Box::new(connection)
}
pub fn authenticate(transport: Transport, credentials: Credentials, device_id: String)
-> Box<Future<Item = (Transport, Credentials), Error = io::Error>>
{
pub fn authenticate(
transport: Transport,
credentials: Credentials,
device_id: String,
) -> Box<Future<Item = (Transport, Credentials), Error = io::Error>> {
use protocol::authentication::{APWelcome, ClientResponseEncrypted, CpuFamily, Os};
let packet = protobuf_init!(ClientResponseEncrypted::new(), {
@ -50,13 +53,13 @@ pub fn authenticate(transport: Transport, credentials: Credentials, device_id: S
let cmd = 0xab;
let data = packet.write_to_bytes().unwrap();
Box::new(transport.send((cmd, data)).and_then(|transport| {
transport.into_future().map_err(|(err, _stream)| err)
}).and_then(|(packet, transport)| {
match packet {
Box::new(
transport
.send((cmd, data))
.and_then(|transport| transport.into_future().map_err(|(err, _stream)| err))
.and_then(|(packet, transport)| match packet {
Some((0xac, data)) => {
let welcome_data: APWelcome =
protobuf::parse_from_bytes(data.as_ref()).unwrap();
let welcome_data: APWelcome = protobuf::parse_from_bytes(data.as_ref()).unwrap();
let reusable_credentials = Credentials {
username: welcome_data.get_canonical_username().to_owned(),
@ -70,6 +73,6 @@ pub fn authenticate(transport: Transport, credentials: Credentials, device_id: S
Some((0xad, _)) => panic!("Authentication failed"),
Some((cmd, _)) => panic!("Unexpected packet {:?}", cmd),
None => panic!("EOF"),
}
}))
}),
)
}

6
core/src/diffie_hellman.rs
View file

@ -43,9 +43,11 @@ impl DHLocalKeys {
}
pub fn shared_secret(&self, remote_key: &[u8]) -> Vec<u8> {
let shared_key = util::powm(&BigUint::from_bytes_be(remote_key),
let shared_key = util::powm(
&BigUint::from_bytes_be(remote_key),
&self.private_key,
&DH_PRIME);
&DH_PRIME,
);
shared_key.to_bytes_be()
}
}

12
core/src/keymaster.rs
View file

@ -13,9 +13,15 @@ pub struct Token {
pub scope: Vec<String>,
}
pub fn get_token(session: &Session, client_id: &str, scopes: &str) -> Box<Future<Item = Token, Error = MercuryError>> {
let url = format!("hm://keymaster/token/authenticated?client_id={}&scope={}",
client_id, scopes);
pub fn get_token(
session: &Session,
client_id: &str,
scopes: &str,
) -> Box<Future<Item = Token, Error = MercuryError>> {
let url = format!(
"hm://keymaster/token/authenticated?client_id={}&scope={}",
client_id, scopes
);
Box::new(session.mercury().get(url).map(move |response| {
let data = response.payload.first().expect("Empty payload");
let data = String::from_utf8(data.clone()).unwrap();

18
core/src/lib.rs
View file

@ -1,10 +1,15 @@
#![cfg_attr(feature = "cargo-clippy", allow(unused_io_amount))]
#[macro_use] extern crate error_chain;
#[macro_use] extern crate futures;
#[macro_use] extern crate lazy_static;
#[macro_use] extern crate log;
#[macro_use] extern crate serde_derive;
#[macro_use]
extern crate error_chain;
#[macro_use]
extern crate futures;
#[macro_use]
extern crate lazy_static;
#[macro_use]
extern crate log;
#[macro_use]
extern crate serde_derive;
extern crate base64;
extern crate byteorder;
@ -26,7 +31,8 @@ extern crate uuid;
extern crate librespot_protocol as protocol;
#[macro_use] mod component;
#[macro_use]
mod component;
mod apresolve;
pub mod audio_key;
pub mod authentication;

33
core/src/mercury/mod.rs
View file

@ -1,7 +1,7 @@
use byteorder::{BigEndian, ByteOrder};
use bytes::Bytes;
use futures::sync::{oneshot, mpsc};
use futures::{Async, Poll, Future};
use futures::{Async, Future, Poll};
use futures::sync::{mpsc, oneshot};
use protobuf;
use protocol;
use std::collections::HashMap;
@ -51,9 +51,7 @@ impl MercuryManager {
seq
}
pub fn request(&self, req: MercuryRequest)
-> MercuryFuture<MercuryResponse>
{
pub fn request(&self, req: MercuryRequest) -> MercuryFuture<MercuryResponse> {
let (tx, rx) = oneshot::channel();
let pending = MercuryPending {
@ -72,9 +70,7 @@ impl MercuryManager {
MercuryFuture(rx)
}
pub fn get<T: Into<String>>(&self, uri: T)
-> MercuryFuture<MercuryResponse>
{
pub fn get<T: Into<String>>(&self, uri: T) -> MercuryFuture<MercuryResponse> {
self.request(MercuryRequest {
method: MercuryMethod::GET,
uri: uri.into(),
@ -83,9 +79,7 @@ impl MercuryManager {
})
}
pub fn send<T: Into<String>>(&self, uri: T, data: Vec<u8>)
-> MercuryFuture<MercuryResponse>
{
pub fn send<T: Into<String>>(&self, uri: T, data: Vec<u8>) -> MercuryFuture<MercuryResponse> {
self.request(MercuryRequest {
method: MercuryMethod::SEND,
uri: uri.into(),
@ -98,9 +92,10 @@ impl MercuryManager {
MercurySender::new(self.clone(), uri.into())
}
pub fn subscribe<T: Into<String>>(&self, uri: T)
-> Box<Future<Item = mpsc::UnboundedReceiver<MercuryResponse>, Error = MercuryError>>
{
pub fn subscribe<T: Into<String>>(
&self,
uri: T,
) -> Box<Future<Item = mpsc::UnboundedReceiver<MercuryResponse>, Error = MercuryError>> {
let uri = uri.into();
let request = self.request(MercuryRequest {
method: MercuryMethod::SUB,
@ -118,8 +113,8 @@ impl MercuryManager {
if response.payload.len() > 0 {
// Old subscription protocol, watch the provided list of URIs
for sub in response.payload {
let mut sub : protocol::pubsub::Subscription
= protobuf::parse_from_bytes(&sub).unwrap();
let mut sub: protocol::pubsub::Subscription =
protobuf::parse_from_bytes(&sub).unwrap();
let sub_uri = sub.take_uri();
debug!("subscribed sub_uri={}", sub_uri);
@ -147,13 +142,11 @@ impl MercuryManager {
let mut pending = match pending {
Some(pending) => pending,
None if cmd == 0xb5 => {
MercuryPending {
None if cmd == 0xb5 => MercuryPending {
parts: Vec::new(),
partial: None,
callback: None,
}
}
},
None => {
warn!("Ignore seq {:?} cmd {:x}", seq, cmd);
return;

2
core/src/mercury/sender.rs
View file

@ -1,5 +1,5 @@
use futures::{Async, AsyncSink, Future, Poll, Sink, StartSend};
use std::collections::VecDeque;
use futures::{Async, Poll, Future, Sink, StartSend, AsyncSink};
use super::*;

11
core/src/mercury/types.rs
View file

@ -37,8 +37,7 @@ impl ToString for MercuryMethod {
MercuryMethod::SUB => "SUB",
MercuryMethod::UNSUB => "UNSUB",
MercuryMethod::SEND => "SEND",
}
.to_owned()
}.to_owned()
}
}
@ -58,7 +57,9 @@ impl MercuryRequest {
packet.write_u16::<BigEndian>(seq.len() as u16).unwrap();
packet.write_all(seq).unwrap();
packet.write_u8(1).unwrap(); // Flags: FINAL
packet.write_u16::<BigEndian>(1 + self.payload.len() as u16).unwrap(); // Part count
packet
.write_u16::<BigEndian>(1 + self.payload.len() as u16)
.unwrap(); // Part count
let mut header = protocol::mercury::Header::new();
header.set_uri(self.uri.clone());
@ -68,7 +69,9 @@ impl MercuryRequest {
header.set_content_type(content_type.clone());
}
packet.write_u16::<BigEndian>(header.compute_size() as u16).unwrap();
packet
.write_u16::<BigEndian>(header.compute_size() as u16)
.unwrap();
header.write_to_writer(&mut packet).unwrap();
for p in &self.payload {

79
core/src/session.rs
View file

@ -1,19 +1,19 @@
use bytes::Bytes;
use crypto::digest::Digest;
use crypto::sha1::Sha1;
use futures::{Async, Future, IntoFuture, Poll, Stream};
use futures::sync::mpsc;
use futures::{Future, Stream, IntoFuture, Poll, Async};
use std::io;
use std::sync::{RwLock, Arc, Weak};
use std::sync::{Arc, RwLock, Weak};
use std::sync::atomic::{AtomicUsize, Ordering, ATOMIC_USIZE_INIT};
use tokio_core::reactor::{Handle, Remote};
use std::sync::atomic::{AtomicUsize, ATOMIC_USIZE_INIT, Ordering};
use apresolve::apresolve_or_fallback;
use authentication::Credentials;
use cache::Cache;
use component::Lazy;
use connection;
use config::SessionConfig;
use connection;
use audio_key::AudioKeyManager;
use channel::ChannelManager;
@ -52,13 +52,14 @@ pub fn device_id(name: &str) -> String {
}
impl Session {
pub fn connect(config: SessionConfig, credentials: Credentials,
cache: Option<Cache>, handle: Handle)
-> Box<Future<Item=Session, Error=io::Error>>
{
pub fn connect(
config: SessionConfig,
credentials: Credentials,
cache: Option<Cache>,
handle: Handle,
) -> Box<Future<Item = Session, Error = io::Error>> {
let access_point = apresolve_or_fallback::<io::Error>(&handle);
let handle_ = handle.clone();
let connection = access_point.and_then(move |addr| {
info!("Connecting to AP \"{}\"", addr);
@ -66,9 +67,8 @@ impl Session {
});
let device_id = config.device_id.clone();
let authentication = connection.and_then(move |connection| {
connection::authenticate(connection, credentials, device_id)
});
let authentication = connection
.and_then(move |connection| connection::authenticate(connection, credentials, device_id));
let result = authentication.map(move |(transport, reusable_credentials)| {
info!("Authenticated as \"{}\" !", reusable_credentials.username);
@ -77,7 +77,11 @@ impl Session {
}
let (session, task) = Session::create(
&handle, transport, config, cache, reusable_credentials.username.clone()
&handle,
transport,
config,
cache,
reusable_credentials.username.clone(),
);
handle.spawn(task.map_err(|e| panic!(e)));
@ -88,10 +92,13 @@ impl Session {
Box::new(result)
}
fn create(handle: &Handle, transport: connection::Transport,
config: SessionConfig, cache: Option<Cache>, username: String)
-> (Session, Box<Future<Item = (), Error = io::Error>>)
{
fn create(
handle: &Handle,
transport: connection::Transport,
config: SessionConfig,
cache: Option<Cache>,
username: String,
) -> (Session, Box<Future<Item = (), Error = io::Error>>) {
let (sink, stream) = transport.split();
let (sender_tx, sender_rx) = mpsc::unbounded();
@ -121,11 +128,15 @@ impl Session {
let sender_task = sender_rx
.map_err(|e| -> io::Error { panic!(e) })
.forward(sink).map(|_| ());
.forward(sink)
.map(|_| ());
let receiver_task = DispatchTask(stream, session.weak());
let task = Box::new((receiver_task, sender_task).into_future()
.map(|((), ())| ()));
let task = Box::new(
(receiver_task, sender_task)
.into_future()
.map(|((), ())| ()),
);
(session, task)
}
@ -143,16 +154,21 @@ impl Session {
}
pub fn spawn<F, R>(&self, f: F)
where F: FnOnce(&Handle) -> R + Send + 'static,
where
F: FnOnce(&Handle) -> R + Send + 'static,
R: IntoFuture<Item = (), Error = ()>,
R::Future: 'static
R::Future: 'static,
{
self.0.handle.spawn(f)
}
fn debug_info(&self) {
debug!("Session[{}] strong={} weak={}",
self.0.session_id, Arc::strong_count(&self.0), Arc::weak_count(&self.0));
debug!(
"Session[{}] strong={} weak={}",
self.0.session_id,
Arc::strong_count(&self.0),
Arc::weak_count(&self.0)
);
}
#[cfg_attr(feature = "cargo-clippy", allow(match_same_arms))]
@ -161,7 +177,7 @@ impl Session {
0x4 => {
self.debug_info();
self.send_packet(0x49, data.as_ref().to_owned());
},
}
0x4a => (),
0x1b => {
let country = String::from_utf8(data.as_ref().to_owned()).unwrap();
@ -229,10 +245,12 @@ impl Drop for SessionInternal {
}
struct DispatchTask<S>(S, SessionWeak)
where S: Stream<Item = (u8, Bytes)>;
where
S: Stream<Item = (u8, Bytes)>;
impl<S> Future for DispatchTask<S>
where S: Stream<Item = (u8, Bytes)>
where
S: Stream<Item = (u8, Bytes)>,
{
type Item = ();
type Error = S::Error;
@ -240,9 +258,7 @@ impl <S> Future for DispatchTask<S>
fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
let session = match self.1.try_upgrade() {
Some(session) => session,
None => {
return Ok(Async::Ready(()))
},
None => return Ok(Async::Ready(())),
};
loop {
@ -253,7 +269,8 @@ impl <S> Future for DispatchTask<S>
}
impl<S> Drop for DispatchTask<S>
where S: Stream<Item = (u8, Bytes)>
where
S: Stream<Item = (u8, Bytes)>,
{
fn drop(&mut self) {
debug!("drop Dispatch");

27
core/src/util/int128.rs
View file

@ -28,12 +28,7 @@ impl std::ops::Add<u128> for u128 {
type Output = u128;
fn add(self, rhs: u128) -> u128 {
let low = self.low + rhs.low;
let high = self.high + rhs.high +
if low < self.low {
1
} else {
0
};
let high = self.high + rhs.high + if low < self.low { 1 } else { 0 };
u128::from_parts(high, low)
}
@ -43,12 +38,7 @@ impl<'a> std::ops::Add<&'a u128> for u128 {
type Output = u128;
fn add(self, rhs: &'a u128) -> u128 {
let low = self.low + rhs.low;
let high = self.high + rhs.high +
if low < self.low {
1
} else {
0
};
let high = self.high + rhs.high + if low < self.low { 1 } else { 0 };
u128::from_parts(high, low)
}
@ -60,20 +50,23 @@ impl std::convert::From<u8> for u128 {
}
}
impl std::ops::Mul<u128> for u128 {
type Output = u128;
fn mul(self, rhs: u128) -> u128 {
let top: [u64; 4] = [self.high >> 32,
let top: [u64; 4] = [
self.high >> 32,
self.high & 0xFFFFFFFF,
self.low >> 32,
self.low & 0xFFFFFFFF];
self.low & 0xFFFFFFFF,
];
let bottom: [u64; 4] = [rhs.high >> 32,
let bottom: [u64; 4] = [
rhs.high >> 32,
rhs.high & 0xFFFFFFFF,
rhs.low >> 32,
rhs.low & 0xFFFFFFFF];
rhs.low & 0xFFFFFFFF,
];
let mut rows = [u128::zero(); 16];
for i in 0..4 {

6
core/src/util/mod.rs
View file

@ -1,7 +1,7 @@
use num_bigint::BigUint;
use num_traits::{Zero, One};
use num_integer::Integer;
use rand::{Rng, Rand};
use num_traits::{One, Zero};
use rand::{Rand, Rng};
use std::mem;
use std::ops::{Mul, Rem, Shr};
@ -9,7 +9,7 @@ mod int128;
mod spotify_id;
pub use util::int128::u128;
pub use util::spotify_id::{SpotifyId, FileId};
pub use util::spotify_id::{FileId, SpotifyId};
pub fn rand_vec<G: Rng, R: Rand>(rng: &mut G, size: usize) -> Vec<R> {
rng.gen_iter().take(size).collect()

5
core/src/util/spotify_id.rs
View file

@ -1,7 +1,7 @@
use byteorder::{BigEndian, ByteOrder};
use std;
use std::fmt;
use util::u128;
use byteorder::{BigEndian, ByteOrder};
// Unneeded since 1.21
#[allow(unused_imports)]
use std::ascii::AsciiExt;
@ -9,8 +9,7 @@ use std::ascii::AsciiExt;
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub struct SpotifyId(u128);
const BASE62_DIGITS: &'static [u8] =
b"0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
const BASE62_DIGITS: &'static [u8] = b"0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
const BASE16_DIGITS: &'static [u8] = b"0123456789abcdef";
impl SpotifyId {