Use element processor for incoming iq set

[?]

Apr 21, 2019, 12:04 PM

JY4F7VBCS4S2YYXT7JQBLPSCWW3K4H3NXH6G5WGJFWWQXN2YPIQAC

Dependencies

[2] LQXBWNFT Remove unneeded requirement
[3] LL3D5CXK Staring using element processor
[4] 4LRBIGVT Show info about xmpp errors
[5] 5A5UVGNM Move receiver closing logic out of xmpp processing
[6] AA2ZWGRL Enter to MUC
[7] PVCRPP3B Some servers don't send to in initial presence
[8] OGMBXBKP Move online to XmppConnection
[9] QTCUURXN Add additional requirement for command stream
[10] FVVPKFTL Initial commit
[11] GVZ4JAR5 Process self-presence with incoming stanza processor
[12] SU4DNVCB Start to processing roster data
[13] X6L47BHQ Use different structure for established xmpp connection
[14] ALP2YJIU Rename XmppState to XmppProcessState
[15] RGOSS73U Convert self-presence to xmpp_parser's type
[16] ZI4GJ72V Add message to xmpp command
[17] NDDQQP2P Update deps
[18] AEH7WP42 Make element processors static
[19] TDOR5XQU Accept destination
[20] VS6AHRWI Move XMPP to separate dir
[21] CP4MZO6V Leftover commands are processed via stoppable receiver
[22] EOHEZXX3 Move request processing to structure
[23] UIXIQHDY Wait for commands via new processing code
[24] AYQZ2UIA Update deps
[25] QWE26TMV update deps
[26] 3GEU7TC7 Welcome to 2018!
[27] 37OMJ4CK Send MUC message
[28] UMTLHH77 Process commands in the separate function
[29] ZFBPXPAD Cleanup timeouted iq requests with ping Output elapsed time. Refactor iq handling.
[30] SYH7UQP6 Make xmpp command enum to allow different commands Save subscription ask status. Don't ask if already requested subscription.
[31] DYRPAV6T Update dependencies
[32] HKSQO7JZ Enable hyper http server and configuration
[33] QYY3KRGL Use failure instead Box<dyn Error>
[34] V5HDBSZM Use jid for receiver address
[35] L3D22A5J Prepare to check incoming presence
[36] BYJPYYSM Process iq ping response
[37] 5GINRCKL Send ping XEP-0199
[38] PBRUH4BJ Rename optional XmppConnection to MaybeXmppConnection
[39] 2THKW66M Ignore .orig files
[40] 5OBTKGDL Update deps
[41] 5Y6YJ6UH Add shutdown function to make actions before offline
[42] IK3YDPTY Update deps
[43] BTOZT4JP Use failure
[44] VW7NVWAG Leave MUC properly
[45] JD62RVOJ Update dependencies
[46] 6UKCVM6E Use new iq processng for initial roster
[47] AGIW6YR3 Use shared future for signal everywhere
[48] FV6BJ5K6 Send self-presence and store account info in Rc so it willbe used in some future in parallel
[49] ACXUIS63 Update dependecies
[50] OFLAP2G2 Fix possible utf8 errors
[51] ZT3YEIVX Consume connection on processing command
[52] PJV5HPIF Starting to imlements timeouts for iqs
[53] 2VZBEEXA Messages fixed
[54] CBWCXUZZ Prepare adding new items to roster
[55] OANBCLN5 Move xmpp client into XmppState
[56] HU3NZX5Z Process self-presence via new processing code
[57] HDLI2X4H Ignore delayed XEP-0203 messages
[58] 5IKA4GO7 Rename xmpp client field from "inner" to "client"
[59] CCLGGFKR Move out XmppConnection into own file
[60] WBU7UOQW Read chatroom from config
[61] RRLRZTMR Use element processor for iq
[62] RQZCVDFD Implement applying timeout for expired iq await
[63] J7VX56FW ToDo
[64] FWJDW3G5 Allow process xmpp incoming stanzas with futures
[65] XGP44R5H Rework stopping xmpp connection
[66] OB3HA2MD Use Client::new_with_jid to parse jid only once
[67] S754Y5DF Refactor IQ processing Always answer to set and get requests. Use XML encoding for stanzas.
[68] TPVUBB3F Answer to ping requests
[69] L77O4T7M Formatting and fixes
[70] 4IPZTMFI Update dependencies
[71] WDCZNZOP Fix rustdoc
[72] PLWPCM47 Add id to initital presence

Change contents

replacement in src/xmpp/xmpp_connection.rs at line 0

[3.21]→[2.0:34146](∅→∅)

use tokio_xmpp::{Client, Event, Packet};

use tokio::prelude::future::{self, Either};
use tokio::prelude::stream;
use tokio::prelude::{Future, Stream};

use std::collections::{HashMap, VecDeque};
use std::time::{Duration, Instant};

use super::stanzas;

use super::element_processor;

use crate::config;

#[derive(Debug)]
pub enum XmppCommand {
/// Send message to someone by jid
Chat {
xmpp_to: xmpp_parsers::Jid,
message: String,
},
/// Send message to MUC
Chatroom { muc_id: String, message: String },
/// Send ping request to the server to test connection
Ping,
/// Check iq requests if some have expired timeouts
TimeoutCleanup,
}

/// trait of processing iq
/// each function consumes handlers and
/// returns false if connection should be reset
trait IqHandler {
/// process result
fn result(
self: Box<Self>,
conn: &mut XmppConnection,
opt_element: Option<xmpp_parsers::Element>,
) -> bool;

/// process error
fn error(
self: Box<Self>,
conn: &mut XmppConnection,
error: xmpp_parsers::stanza_error::StanzaError,
) -> bool;

/// process tmeout
fn timeout(self: Box<Self>, conn: &mut XmppConnection) -> bool;
}

struct AddRosterIqHandler {
jid: xmpp_parsers::Jid,
}

impl IqHandler for AddRosterIqHandler {
fn result(
self: Box<Self>,
conn: &mut XmppConnection,
opt_element: Option<xmpp_parsers::Element>,
) -> bool {
match opt_element {
Some(element) => {
warn!(
"Wrong payload when adding {} to roster: {}",
self.jid,
String::from(&element)
);
}
None => {
if conn.state.data.roster.contains_key(&self.jid) {
info!("Jid {} updated to roster", self.jid);
} else {
info!("Jid {} added in roster", self.jid);
conn.state.data.roster.insert(
self.jid.clone(),
(
xmpp_parsers::roster::Subscription::None,
xmpp_parsers::roster::Ask::None,
),
);
}
conn.process_jid(&self.jid);
}
}
true
}

fn error(
self: Box<Self>,
_conn: &mut XmppConnection,
_error: xmpp_parsers::stanza_error::StanzaError,
) -> bool {
true
}

fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
true // ignore
}
}

struct PingIqHandler {}

impl IqHandler for PingIqHandler {
fn result(
self: Box<Self>,
_conn: &mut XmppConnection,
_opt_element: Option<xmpp_parsers::Element>,
) -> bool {
info!("ping successed");
true
}

fn error(
self: Box<Self>,
_conn: &mut XmppConnection,
_error: xmpp_parsers::stanza_error::StanzaError,
) -> bool {
false
}

fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
false
}
}

struct InitRosterIqHandler {}

impl IqHandler for InitRosterIqHandler {
fn result(
self: Box<Self>,
conn: &mut XmppConnection,
opt_element: Option<xmpp_parsers::Element>,
) -> bool {
if let Some(result) = opt_element {
use std::convert::TryInto;
match result.try_into() as Result<xmpp_parsers::roster::Roster, _> {
Ok(roster) => {
conn.state.data.roster_init = true;
conn.state.data.roster.clear();
info!("Got first roster:");
for i in roster.items {
info!(" >>> {:?}", i);
conn.state
.data
.roster
.insert(i.jid, (i.subscription, i.ask));
}
true
}
Err(e) => {
error!("Cann't parse roster: {}", e);
false
}
}
} else {
error!("No roster responded");
false
}
}

fn error(
self: Box<Self>,
_conn: &mut XmppConnection,
_error: xmpp_parsers::stanza_error::StanzaError,
) -> bool {
false
}

fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
false
}
}

#[derive(Default)]
struct XmppData {
/// known roster data
roster: HashMap<
xmpp_parsers::Jid,
(
xmpp_parsers::roster::Subscription,
xmpp_parsers::roster::Ask,
),
>,
/// if roster was initialized
/// ToDo: remove it as it is used only for initialization
roster_init: bool,
/// if self-presence accepted
/// ToDo: remove it as it is used only for initialization
self_presence: bool,
/// ids counter
counter: usize,
/// stanzas to send
send_queue: VecDeque<minidom::Element>,
/// outgoing mailbox
outgoing_mailbox: HashMap<xmpp_parsers::Jid, Vec<String>>,
/// muc id to muc jid
mucs: HashMap<String, xmpp_parsers::Jid>,
/// map from iq's id to handler of this type of iqs
pending_ids: HashMap<String, (Instant, Box<dyn IqHandler>)>,
}

struct XmppState {
client: Client,
data: XmppData,
}

pub struct XmppConnection {
account: std::rc::Rc<config::Account>,
state: XmppState,
}

lazy_static! {
static ref INCOMING: element_processor::Processor<XmppConnection, bool, xmpp_parsers::Element> = {
let mut incoming = element_processor::Processor::new(&|_, e| {
warn!("Unknown stanza {}", String::from(&e));
true
});
incoming.register(&XmppConnection::incoming_iq_processing);
incoming.register(&XmppConnection::incoming_presence_processing);
incoming.register(&XmppConnection::incoming_message_processing);
incoming
};
}

pub struct MaybeXmppConnection {
account: std::rc::Rc<config::Account>,
state: Option<XmppState>,
}

impl From<XmppConnection> for MaybeXmppConnection {
fn from(from: XmppConnection) -> MaybeXmppConnection {
MaybeXmppConnection {
account: from.account,
state: Some(from.state),
}
}
}

impl From<config::Account> for MaybeXmppConnection {
fn from(from: config::Account) -> MaybeXmppConnection {
MaybeXmppConnection {
account: std::rc::Rc::new(from),
state: None,
}
}
}

impl From<std::rc::Rc<config::Account>> for MaybeXmppConnection {
fn from(from: std::rc::Rc<config::Account>) -> MaybeXmppConnection {
MaybeXmppConnection {
account: from,
state: None,
}
}
}

impl MaybeXmppConnection {
/// connects if nothing connected
/// don't connect only if stop_future resolved
pub fn connect<F>(
self,
stop_future: F,
) -> impl Future<Item = XmppConnection, Error = failure::Error>
where
F: future::Future + Clone + 'static,
<F as hyper::rt::Future>::Error: Into<failure::Error> + Send,
{
info!("xmpp connection...");
let MaybeXmppConnection { account, state } = self;

if let Some(state) = state {
Box::new(future::ok(XmppConnection { account, state }))
as Box<dyn Future<Item = _, Error = _>>
} else {
Box::new(
stop_future
.clone()
.select2(
future::loop_fn(account, move |account| {
info!("xmpp initialization...");
let client =
Client::new_with_jid(account.jid.clone(), &account.password);
info!("xmpp initialized");

let stop_future2 = stop_future.clone();
let stop_future3 = stop_future.clone();
let stop_future4 = stop_future.clone();

// future to wait for online
Box::new(
XmppConnection {
state: XmppState {
client,
data: std::default::Default::default(),
},
account,
}
.processing(XmppConnection::online, stop_future.clone())
.map_err(|(acc, _)| acc)
.and_then(|(conn, r)| match r {
Ok(Either::A(_)) => future::ok(conn),
Ok(Either::B(_)) => future::err(conn.account),
Err(_e) => future::err(conn.account),
})
.and_then(|conn| conn.initial_roster(stop_future2))
.and_then(|conn| conn.self_presence(stop_future3))
.and_then(|conn| conn.enter_mucs(stop_future4))
.then(|r| match r {
Ok(conn) => future::ok(future::Loop::Break(conn)),
Err(acc) => future::ok(future::Loop::Continue(acc)),
}),
)
})
.map_err(|_: ()| ()),
)
.then(|r| match r {
Ok(Either::A((_x, _b))) => future::err(format_err!("Stop XMMP connection")),
Ok(Either::B((x, _a))) => future::ok(x),
Err(Either::A((e, _b))) => future::err(e.into()),
Err(Either::B((_, _a))) => {
future::err(format_err!("Cann't initiate XMPP connection"))
}
}),
)
}
}
}

impl XmppConnection {
/// base XMPP processing
/// Returns false on error to disconnect
fn xmpp_processing(&mut self, event: &Event) -> bool {
match event {
Event::Stanza(stanza) => INCOMING.process(self, stanza.clone()),
Event::Online => true,
e => {
warn!("Unexpected event {:?}", e);
false
}
}
}

/// Enforce to answer to IQ "set"
fn incoming_iq_processing_set(
&mut self,
id: String,
from: Option<xmpp_parsers::Jid>,
element: minidom::Element,
) -> xmpp_parsers::iq::Iq {
use std::convert::TryInto;
if let Some(roster) =
element.clone().try_into().ok() as Option<xmpp_parsers::roster::Roster>
{
// RFC 6212 2.1.6. Roster Push
info!("Got roster push {} from {:?}", id, from);
for i in roster.items {
if let Some(ref mut rdata) = self.state.data.roster.get_mut(&i.jid) {
info!("Update {} in roster", i.jid);
rdata.0 = i.subscription;
rdata.1 = i.ask;
} else {
info!("Add {} to roster", i.jid);
self.state
.data
.roster
.insert(i.jid.clone(), (i.subscription, i.ask));
}
self.process_jid(&i.jid);
}
return stanzas::make_roster_push_answer(id, self.state.client.jid.clone(), from);
}
warn!(
"Unsupported IQ set request from {:?}: {}",
from,
String::from(&element)
);
stanzas::make_iq_unsupported_error(id, self.state.client.jid.clone(), from)
}

/// Enforce to answer to IQ "get"
fn incoming_iq_processing_get(
&mut self,
id: String,
from: Option<xmpp_parsers::Jid>,
element: minidom::Element,
) -> xmpp_parsers::iq::Iq {
use std::convert::TryInto;
if let Some(_ping) = element.clone().try_into().ok() as Option<xmpp_parsers::ping::Ping> {
info!("Got ping {} from {:?}", id, from);
return stanzas::make_pong(&id, self.state.client.jid.clone(), from);
}
warn!(
"Unsupported IQ get request from {:?}: {}",
from,
String::from(&element)
);
stanzas::make_iq_unsupported_error(id, self.state.client.jid.clone(), from)
}

fn incoming_iq_processing(&mut self, iq: xmpp_parsers::iq::Iq) -> bool {
match iq.payload {
xmpp_parsers::iq::IqType::Set(element) => {
let iq_answer = self.incoming_iq_processing_set(iq.id, iq.from, element);
self.state.data.send_queue.push_back(iq_answer.into());
}
xmpp_parsers::iq::IqType::Error(e) => {
if let Some((_, handler)) = self.state.data.pending_ids.remove_entry(&iq.id) {
return handler.1.error(self, e);
}
error!("iq error: {:?}", e);
return false;
}
xmpp_parsers::iq::IqType::Get(element) => {
let iq_answer = self.incoming_iq_processing_get(iq.id, iq.from, element);
self.state.data.send_queue.push_back(iq_answer.into());
}
xmpp_parsers::iq::IqType::Result(opt_element) => {
if let Some((_, handler)) = self.state.data.pending_ids.remove_entry(&iq.id) {
return handler.1.result(self, opt_element);
}
warn!(
"Unwanted iq result id {} from {:?}: {:?}",
iq.id,
iq.from,
opt_element.map(|e| String::from(&e))
);
}
}
true
}

fn incoming_presence_processing(&mut self, presence: xmpp_parsers::presence::Presence) -> bool {
if presence.from.as_ref() == Some(&self.state.client.jid) {
info!("Self-presence accepted");
self.state.data.self_presence = true;
} else {
warn!("Incoming presence stanza: {:?}", presence);
}
true
}

fn incoming_message_processing(&mut self, message: xmpp_parsers::message::Message) -> bool {
for payload in message.payloads.iter() {
use std::convert::TryInto;
if let Some(_delay) =
payload.clone().try_into().ok() as Option<xmpp_parsers::delay::Delay>
{
return true; // ignore delayed messages
}
}
warn!("Incoming message stanza: {:?}", message);
true
}

/// process event from xmpp stream
/// returns from future when condition met
/// or stop future was resolved.
/// Return item if connection was preserved or error otherwise.
/// Second part is a state of stop_future
pub fn processing<S, F, T, E>(
self,
stop_condition: S,
stop_future: F,
) -> impl Future<
Item = (Self, Result<Either<F, T>, E>),
Error = (std::rc::Rc<config::Account>, Result<Either<F, T>, E>),
>
where
F: Future<Item = T, Error = E> + 'static,
S: FnMut(&mut Self, Event) -> Result<bool, ()> + 'static,
T: 'static,
E: 'static,
{
future::loop_fn(
(self, stop_future, stop_condition),
|(xmpp, stop_future, mut stop_condition)| {
// ToDo: check timeouts if iqs

let XmppConnection {
state: XmppState { client, mut data },
account,
} = xmpp;

if let Some(send_element) = data.send_queue.pop_front() {
use tokio::prelude::Sink;

info!("Sending {}", String::from(&send_element));
Box::new(
client
.send(Packet::Stanza(send_element))
.select2(stop_future)
.then(move |r| match r {
Ok(Either::A((client, b))) => {
Box::new(future::ok(future::Loop::Continue((
XmppConnection {
state: XmppState { client, data },
account,
},
b,
stop_condition,
))))
as Box<dyn Future<Item = _, Error = _>>
}
Ok(Either::B((t, a))) => Box::new(a.then(|r| match r {
Ok(client) => future::ok(future::Loop::Break((
XmppConnection {
state: XmppState { client, data },
account,
},
Ok(Either::B(t)),
))),
Err(se) => {
warn!("XMPP sending error: {}", se);
future::err((account, Ok(Either::B(t))))
}
})),
Err(Either::A((e, b))) => {
warn!("XMPP sending error: {}", e);
Box::new(future::err((account, Ok(Either::A(b)))))
}
Err(Either::B((e, a))) => Box::new(a.then(|r| match r {
Ok(client) => future::ok(future::Loop::Break((
XmppConnection {
state: XmppState { client, data },
account,
},
Err(e),
))),
Err(se) => {
warn!("XMPP sending error: {}", se);
future::err((account, Err(e)))
}
})),
}),
) as Box<dyn Future<Item = _, Error = _>>
} else {
Box::new(
client
.into_future()
.select2(stop_future)
.then(move |r| match r {
Ok(Either::A(((event, client), b))) => {
if let Some(event) = event {
let mut xmpp = XmppConnection {
state: XmppState { client, data },
account,
};

if xmpp.xmpp_processing(&event) {
match stop_condition(&mut xmpp, event) {
Ok(true) => future::ok(future::Loop::Break((
xmpp,
Ok(Either::A(b)),
))),
Ok(false) => future::ok(future::Loop::Continue((
xmpp,
b,
stop_condition,
))),
Err(_e) => {
future::err((xmpp.account, Ok(Either::A(b))))
}
}
} else {
future::err((xmpp.account, Ok(Either::A(b))))
}
} else {
future::err((account, Ok(Either::A(b))))
}
}
Ok(Either::B((t, a))) => {
if let Some(client) = a.into_inner() {
future::ok(future::Loop::Break((
XmppConnection {
state: XmppState { client, data },
account,
},
Ok(Either::B(t)),
)))
} else {
future::err((account, Ok(Either::B(t))))
}
}
Err(Either::A((e, b))) => {
warn!("XMPP error: {}", e.0);
future::err((account, Ok(Either::A(b))))
}
Err(Either::B((e, a))) => {
if let Some(client) = a.into_inner() {
future::ok(future::Loop::Break((
XmppConnection {
state: XmppState { client, data },
account,
},
Err(e),
)))
} else {
future::err((account, Err(e)))
}
}
}),
)
}
},
)
}

/// get connection and wait for online status and set presence
/// returns error if something went wrong and xmpp connection is broken
fn online(&mut self, event: Event) -> Result<bool, ()> {
match event {
Event::Online => {
info!("Online!");
Ok(true)
}
Event::Stanza(s) => {
warn!("Stanza before online: {}", String::from(&s));
Ok(false)
}
_ => {
error!("Disconnected while online");
Err(())
}
}
}

fn initial_roster<F, E>(
self,
stop_future: F,
) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>>
where
F: Future<Error = E> + 'static,
E: 'static,
{
let XmppConnection {
account,
state: XmppState { client, mut data },
} = self;
use tokio::prelude::Sink;

data.counter += 1;
let id_init_roster = format!("id_init_roster{}", data.counter);
let get_roster = stanzas::make_get_roster(&id_init_roster);
let account2 = account.clone();
info!("Quering roster... {}", String::from(&get_roster));
data.pending_ids.insert(
id_init_roster.clone(),
(
Instant::now() + Duration::from_secs(60),
Box::new(InitRosterIqHandler {}),
),
);

client
.send(Packet::Stanza(get_roster))
.map_err(move |e| {
error!("Error on querying roster: {}", e);
account2
})
.and_then(move |client| {
XmppConnection {
state: XmppState { client, data },
account,
}
.processing(move |conn, _| Ok(conn.state.data.roster_init), stop_future)
.map_err(|(account, _)| account)
.and_then(|(conn, r)| match r {
Ok(Either::A(_)) => future::ok(conn),
Ok(Either::B(_)) => future::err(conn.account),
Err(_e) => future::err(conn.account),
})
})
}

fn self_presence<F, E>(
self,
stop_future: F,
) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>>
where
F: Future<Error = E> + 'static,
E: Into<failure::Error> + 'static,
{
let XmppConnection {
account,
state: XmppState { client, data },
} = self;
use tokio::prelude::Sink;

let presence = stanzas::make_presence(&account);
let account2 = account.clone();
info!("Sending presence... {}", String::from(&presence));

client
.send(Packet::Stanza(presence))
.map_err(|e| {
error!("Error on send self-presence: {}", e);
account2
})
.and_then(move |client| {
XmppConnection {
state: XmppState { client, data },
account,
}
.processing(
move |conn, _| Ok(conn.state.data.self_presence),
stop_future,
)
.map_err(|(account, _)| account)
.and_then(|(conn, r)| match r {
Ok(Either::A(_)) => future::ok(conn),
Ok(Either::B(_)) => future::err(conn.account),
Err(_e) => future::err(conn.account),
})
})
}

fn process_jid(&mut self, xmpp_to: &xmpp_parsers::Jid) {
if let Some(ref mut mailbox) = self.state.data.outgoing_mailbox.get_mut(xmpp_to) {
if !mailbox.is_empty() {
if let Some(ref mut rdata) = self.state.data.roster.get_mut(xmpp_to) {
info!("Jid {} in roster", xmpp_to);
let sub_to = match rdata.0 {
xmpp_parsers::roster::Subscription::To => true,
xmpp_parsers::roster::Subscription::Both => true,
_ => false,
};
if sub_to {
info!("Subscribed to {}", xmpp_to);
self.state.data.send_queue.extend(
mailbox.drain(..).map(|message| {
stanzas::make_chat_message(xmpp_to.clone(), message)
}),
);
} else if rdata.1 == xmpp_parsers::roster::Ask::None {
info!("Not subscribed to {}", xmpp_to);
self.state
.data
.send_queue
.push_back(stanzas::make_ask_subscribe(xmpp_to.clone()));
}
let sub_from = match rdata.0 {
xmpp_parsers::roster::Subscription::From => true,
xmpp_parsers::roster::Subscription::Both => true,
_ => false,
};
if !sub_from {
info!("Not subscription from {}", xmpp_to);
self.state
.data
.send_queue
.push_back(stanzas::make_allow_subscribe(xmpp_to.clone()));
}
} else {
info!("Jid {} not in roster", xmpp_to);

self.state.data.counter += 1;
let id_add_roster = format!("id_add_roster{}", self.state.data.counter);
let add_roster = stanzas::make_add_roster(&id_add_roster, xmpp_to.clone());
info!("Adding jid {} to roster id {}", xmpp_to, id_add_roster);
self.state.data.pending_ids.insert(
id_add_roster,
(
Instant::now() + Duration::from_secs(60),
Box::new(AddRosterIqHandler {
jid: xmpp_to.clone(),
}),
),
);
self.state.data.send_queue.push_back(add_roster);
}
}
}
}

pub fn process_command(&mut self, cmd: XmppCommand) {
info!("Got command");
match cmd {
XmppCommand::Chat { xmpp_to, message } => {
self.state
.data
.outgoing_mailbox
.entry(xmpp_to.clone())
.or_default()
.push(message);
self.process_jid(&xmpp_to);
}
XmppCommand::Chatroom { muc_id, message } => {
if let Some(muc) = self.state.data.mucs.get(&muc_id) {
self.state
.data
.send_queue
.push_back(stanzas::make_muc_message(muc.clone(), message));
} else {
error!("Not found MUC {}", muc_id);
}
}
XmppCommand::Ping => {
self.state.data.counter += 1;
let id_ping = format!("id_ping{}", self.state.data.counter);
let ping = stanzas::make_ping(&id_ping, self.state.client.jid.clone());
self.state.data.send_queue.push_back(ping);
self.state.data.pending_ids.insert(
id_ping,
(
Instant::now() + Duration::from_secs(30),
Box::new(PingIqHandler {}),
),
);
}
XmppCommand::TimeoutCleanup => {
let now = Instant::now();
let timeouted: Vec<String> = self
.state
.data
.pending_ids
.iter()
.filter_map(|(id, (timeout, _))| {
if now >= *timeout {
Some(id.to_string())
} else {
None
}
})
.collect();
let mut correct = true;
timeouted.into_iter().for_each(|id| {
if let Some((_, handler)) = self.state.data.pending_ids.remove(&id) {
correct &= handler.timeout(&mut self);
}
})
}
}
}

pub fn shutdown(self) -> impl Future<Item = (), Error = failure::Error> {
info!("Shutdown connection");
let XmppConnection { account, state } = self;
stream::iter_ok(
state
.data
.mucs
.values()
.map(std::clone::Clone::clone)
.collect::<Vec<_>>(),
)
.fold(state, move |XmppState { client, data }, muc_jid| {
let muc_presence =
stanzas::make_muc_presence_leave(account.jid.clone(), muc_jid.clone());

info!(
"Sending muc leave presence... {}",
String::from(&muc_presence)
);
use tokio::prelude::Sink;
client
.send(Packet::Stanza(muc_presence))
.map_err(|e| {
error!("Error on send muc presence: {}", e);
e
})
.and_then(|client| future::ok(XmppState { client, data }))
})
.map(|_| ())
}

fn enter_mucs<F, E>(
self,
_stop_future: F,
) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>>
where
F: Future<Error = E> + 'static,
E: Into<failure::Error> + 'static,
{
let XmppConnection { account, state } = self;

let account2 = account.clone();
let account3 = account.clone();

stream::iter_ok(account.chatrooms.clone())
.fold(state, move |XmppState { client, mut data }, muc_jid| {
data.counter += 1;
let id_muc_presence = format!("id_muc_presence{}", data.counter);
let muc_presence = stanzas::make_muc_presence(
&id_muc_presence,
account2.jid.clone(),
muc_jid.1.clone(),
);

info!("Sending muc presence... {}", String::from(&muc_presence));

let account4 = account2.clone();

use tokio::prelude::Sink;
client
.send(Packet::Stanza(muc_presence))
.map_err(|e| {
error!("Error on send muc presence: {}", e);
account4
})
.and_then(|client| {
data.mucs.insert(muc_jid.0, muc_jid.1);
future::ok(XmppState { client, data })
})
})
.map(|state| XmppConnection {
account: account3,
state,
})
}
}

[3.21]

use tokio_xmpp::{Client, Event, Packet};

use tokio::prelude::future::{self, Either};
use tokio::prelude::stream;
use tokio::prelude::{Future, Stream};

use std::collections::{HashMap, VecDeque};
use std::time::{Duration, Instant};

use super::stanzas;

use super::element_processor;

use crate::config;

#[derive(Debug)]
pub enum XmppCommand {
/// Send message to someone by jid
Chat {
xmpp_to: xmpp_parsers::Jid,
message: String,
},
/// Send message to MUC
Chatroom { muc_id: String, message: String },
/// Send ping request to the server to test connection
Ping,
/// Check iq requests if some have expired timeouts
TimeoutCleanup,
}

/// trait of processing iq
/// each function consumes handlers and
/// returns false if connection should be reset
trait IqHandler {
/// process result
fn result(
self: Box<Self>,
conn: &mut XmppConnection,
opt_element: Option<xmpp_parsers::Element>,
) -> bool;

/// process error
fn error(
self: Box<Self>,
conn: &mut XmppConnection,
error: xmpp_parsers::stanza_error::StanzaError,
) -> bool;

/// process tmeout
fn timeout(self: Box<Self>, conn: &mut XmppConnection) -> bool;
}

struct AddRosterIqHandler {
jid: xmpp_parsers::Jid,
}

impl IqHandler for AddRosterIqHandler {
fn result(
self: Box<Self>,
conn: &mut XmppConnection,
opt_element: Option<xmpp_parsers::Element>,
) -> bool {
match opt_element {
Some(element) => {
warn!(
"Wrong payload when adding {} to roster: {}",
self.jid,
String::from(&element)
);
}
None => {
if conn.state.data.roster.contains_key(&self.jid) {
info!("Jid {} updated to roster", self.jid);
} else {
info!("Jid {} added in roster", self.jid);
conn.state.data.roster.insert(
self.jid.clone(),
(
xmpp_parsers::roster::Subscription::None,
xmpp_parsers::roster::Ask::None,
),
);
}
conn.process_jid(&self.jid);
}
}
true
}

fn error(
self: Box<Self>,
_conn: &mut XmppConnection,
_error: xmpp_parsers::stanza_error::StanzaError,
) -> bool {
true
}

fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
true // ignore
}
}

struct PingIqHandler {}

impl IqHandler for PingIqHandler {
fn result(
self: Box<Self>,
_conn: &mut XmppConnection,
_opt_element: Option<xmpp_parsers::Element>,
) -> bool {
info!("ping successed");
true
}

fn error(
self: Box<Self>,
_conn: &mut XmppConnection,
_error: xmpp_parsers::stanza_error::StanzaError,
) -> bool {
false
}

fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
false
}
}

struct InitRosterIqHandler {}

impl IqHandler for InitRosterIqHandler {
fn result(
self: Box<Self>,
conn: &mut XmppConnection,
opt_element: Option<xmpp_parsers::Element>,
) -> bool {
if let Some(result) = opt_element {
use std::convert::TryInto;
match result.try_into() as Result<xmpp_parsers::roster::Roster, _> {
Ok(roster) => {
conn.state.data.roster_init = true;
conn.state.data.roster.clear();
info!("Got first roster:");
for i in roster.items {
info!(" >>> {:?}", i);
conn.state
.data
.roster
.insert(i.jid, (i.subscription, i.ask));
}
true
}
Err(e) => {
error!("Cann't parse roster: {}", e);
false
}
}
} else {
error!("No roster responded");
false
}
}

fn error(
self: Box<Self>,
_conn: &mut XmppConnection,
_error: xmpp_parsers::stanza_error::StanzaError,
) -> bool {
false
}

fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
false
}
}

#[derive(Default)]
struct XmppData {
/// known roster data
roster: HashMap<
xmpp_parsers::Jid,
(
xmpp_parsers::roster::Subscription,
xmpp_parsers::roster::Ask,
),
>,
/// if roster was initialized
/// ToDo: remove it as it is used only for initialization
roster_init: bool,
/// if self-presence accepted
/// ToDo: remove it as it is used only for initialization
self_presence: bool,
/// ids counter
counter: usize,
/// stanzas to send
send_queue: VecDeque<minidom::Element>,
/// outgoing mailbox
outgoing_mailbox: HashMap<xmpp_parsers::Jid, Vec<String>>,
/// muc id to muc jid
mucs: HashMap<String, xmpp_parsers::Jid>,
/// map from iq's id to handler of this type of iqs
pending_ids: HashMap<String, (Instant, Box<dyn IqHandler>)>,
}

struct XmppState {
client: Client,
data: XmppData,
}

pub struct XmppConnection {
account: std::rc::Rc<config::Account>,
state: XmppState,
}

trait IqSetHandler {
fn process(
self: Box<Self>,
conn: &mut XmppConnection,
id: String,
from: Option<xmpp_parsers::Jid>,
) -> xmpp_parsers::iq::Iq;
}

struct IqSetUnknown {
element: xmpp_parsers::Element,
}

impl IqSetHandler for IqSetUnknown {
fn process(
self: Box<Self>,
conn: &mut XmppConnection,
id: String,
from: Option<xmpp_parsers::Jid>,
) -> xmpp_parsers::iq::Iq {
warn!(
"Unsupported IQ set request from {:?}: {}",
from,
String::from(&self.element)
);
stanzas::make_iq_unsupported_error(id, conn.state.client.jid.clone(), from)
}
}

struct IqSetRoster {}

impl IqSetHandler for IqSetRoster {
fn process(
self: Box<Self>,
conn: &mut XmppConnection,
id: String,
from: Option<xmpp_parsers::Jid>,
) -> xmpp_parsers::iq::Iq {
info!("Got roster push {} from {:?}", id, from);
stanzas::make_roster_push_answer(id, conn.state.client.jid.clone(), from)
}
}

lazy_static! {
static ref INCOMING: element_processor::Processor<XmppConnection, bool, xmpp_parsers::Element> = {
let mut incoming = element_processor::Processor::new(&|_, e| {
warn!("Unknown stanza {}", String::from(&e));
true
});
incoming.register(&XmppConnection::incoming_iq_processing);
incoming.register(&XmppConnection::incoming_presence_processing);
incoming.register(&XmppConnection::incoming_message_processing);
incoming
};
static ref INCOMING_IQ_SET: element_processor::Processor<XmppConnection, Box<dyn IqSetHandler>, xmpp_parsers::Element> = {
let mut iq_set =
element_processor::Processor::new(&|_conn: &mut XmppConnection, element| {
Box::new(IqSetUnknown { element }) as Box<dyn IqSetHandler>
});
iq_set.register(&XmppConnection::incoming_iq_processing_set_roster);
iq_set
};
}

pub struct MaybeXmppConnection {
account: std::rc::Rc<config::Account>,
state: Option<XmppState>,
}

impl From<XmppConnection> for MaybeXmppConnection {
fn from(from: XmppConnection) -> MaybeXmppConnection {
MaybeXmppConnection {
account: from.account,
state: Some(from.state),
}
}
}

impl From<config::Account> for MaybeXmppConnection {
fn from(from: config::Account) -> MaybeXmppConnection {
MaybeXmppConnection {
account: std::rc::Rc::new(from),
state: None,
}
}
}

impl From<std::rc::Rc<config::Account>> for MaybeXmppConnection {
fn from(from: std::rc::Rc<config::Account>) -> MaybeXmppConnection {
MaybeXmppConnection {
account: from,
state: None,
}
}
}

impl MaybeXmppConnection {
/// connects if nothing connected
/// don't connect only if stop_future resolved
pub fn connect<F>(
self,
stop_future: F,
) -> impl Future<Item = XmppConnection, Error = failure::Error>
where
F: future::Future + Clone + 'static,
<F as hyper::rt::Future>::Error: Into<failure::Error> + Send,
{
info!("xmpp connection...");
let MaybeXmppConnection { account, state } = self;

if let Some(state) = state {
Box::new(future::ok(XmppConnection { account, state }))
as Box<dyn Future<Item = _, Error = _>>
} else {
Box::new(
stop_future
.clone()
.select2(
future::loop_fn(account, move |account| {
info!("xmpp initialization...");
let client =
Client::new_with_jid(account.jid.clone(), &account.password);
info!("xmpp initialized");

let stop_future2 = stop_future.clone();
let stop_future3 = stop_future.clone();
let stop_future4 = stop_future.clone();

// future to wait for online
Box::new(
XmppConnection {
state: XmppState {
client,
data: std::default::Default::default(),
},
account,
}
.processing(XmppConnection::online, stop_future.clone())
.map_err(|(acc, _)| acc)
.and_then(|(conn, r)| match r {
Ok(Either::A(_)) => future::ok(conn),
Ok(Either::B(_)) => future::err(conn.account),
Err(_e) => future::err(conn.account),
})
.and_then(|conn| conn.initial_roster(stop_future2))
.and_then(|conn| conn.self_presence(stop_future3))
.and_then(|conn| conn.enter_mucs(stop_future4))
.then(|r| match r {
Ok(conn) => future::ok(future::Loop::Break(conn)),
Err(acc) => future::ok(future::Loop::Continue(acc)),
}),
)
})
.map_err(|_: ()| ()),
)
.then(|r| match r {
Ok(Either::A((_x, _b))) => future::err(format_err!("Stop XMMP connection")),
Ok(Either::B((x, _a))) => future::ok(x),
Err(Either::A((e, _b))) => future::err(e.into()),
Err(Either::B((_, _a))) => {
future::err(format_err!("Cann't initiate XMPP connection"))
}
}),
)
}
}
}

impl XmppConnection {
/// base XMPP processing
/// Returns false on error to disconnect
fn xmpp_processing(&mut self, event: &Event) -> bool {
match event {
Event::Stanza(stanza) => INCOMING.process(self, stanza.clone()),
Event::Online => true,
e => {
warn!("Unexpected event {:?}", e);
false
}
}
}

fn incoming_iq_processing_set_roster(
&mut self,
roster: xmpp_parsers::roster::Roster,
) -> Box<dyn IqSetHandler> {
for i in roster.items {
if let Some(ref mut rdata) = self.state.data.roster.get_mut(&i.jid) {
info!("Update {} in roster", i.jid);
rdata.0 = i.subscription;
rdata.1 = i.ask;
} else {
info!("Add {} to roster", i.jid);
self.state
.data
.roster
.insert(i.jid.clone(), (i.subscription, i.ask));
}
self.process_jid(&i.jid);
}
Box::new(IqSetRoster {})
}

/// Enforce to answer to IQ "set"
fn incoming_iq_processing_set(
&mut self,
id: String,
from: Option<xmpp_parsers::Jid>,
element: minidom::Element,
) -> xmpp_parsers::iq::Iq {
INCOMING_IQ_SET
.process(self, element)
.process(self, id, from)
}

/// Enforce to answer to IQ "get"
fn incoming_iq_processing_get(
&mut self,
id: String,
from: Option<xmpp_parsers::Jid>,
element: minidom::Element,
) -> xmpp_parsers::iq::Iq {
use std::convert::TryInto;
if let Some(_ping) = element.clone().try_into().ok() as Option<xmpp_parsers::ping::Ping> {
info!("Got ping {} from {:?}", id, from);
return stanzas::make_pong(&id, self.state.client.jid.clone(), from);
}
warn!(
"Unsupported IQ get request from {:?}: {}",
from,
String::from(&element)
);
stanzas::make_iq_unsupported_error(id, self.state.client.jid.clone(), from)
}

fn incoming_iq_processing(&mut self, iq: xmpp_parsers::iq::Iq) -> bool {
match iq.payload {
xmpp_parsers::iq::IqType::Set(element) => {
let iq_answer = self.incoming_iq_processing_set(iq.id, iq.from, element);
self.state.data.send_queue.push_back(iq_answer.into());
}
xmpp_parsers::iq::IqType::Error(e) => {
if let Some((_, handler)) = self.state.data.pending_ids.remove_entry(&iq.id) {
return handler.1.error(self, e);
}
error!("iq error: {:?}", e);
return false;
}
xmpp_parsers::iq::IqType::Get(element) => {
let iq_answer = self.incoming_iq_processing_get(iq.id, iq.from, element);
self.state.data.send_queue.push_back(iq_answer.into());
}
xmpp_parsers::iq::IqType::Result(opt_element) => {
if let Some((_, handler)) = self.state.data.pending_ids.remove_entry(&iq.id) {
return handler.1.result(self, opt_element);
}
warn!(
"Unwanted iq result id {} from {:?}: {:?}",
iq.id,
iq.from,
opt_element.map(|e| String::from(&e))
);
}
}
true
}

fn incoming_presence_processing(&mut self, presence: xmpp_parsers::presence::Presence) -> bool {
if presence.from.as_ref() == Some(&self.state.client.jid) {
info!("Self-presence accepted");
self.state.data.self_presence = true;
} else {
warn!("Incoming presence stanza: {:?}", presence);
}
true
}

fn incoming_message_processing(&mut self, message: xmpp_parsers::message::Message) -> bool {
for payload in message.payloads.iter() {
use std::convert::TryInto;
if let Some(_delay) =
payload.clone().try_into().ok() as Option<xmpp_parsers::delay::Delay>
{
return true; // ignore delayed messages
}
}
warn!("Incoming message stanza: {:?}", message);
true
}

/// process event from xmpp stream
/// returns from future when condition met
/// or stop future was resolved.
/// Return item if connection was preserved or error otherwise.
/// Second part is a state of stop_future
pub fn processing<S, F, T, E>(
self,
stop_condition: S,
stop_future: F,
) -> impl Future<
Item = (Self, Result<Either<F, T>, E>),
Error = (std::rc::Rc<config::Account>, Result<Either<F, T>, E>),
>
where
F: Future<Item = T, Error = E> + 'static,
S: FnMut(&mut Self, Event) -> Result<bool, ()> + 'static,
T: 'static,
E: 'static,
{
future::loop_fn(
(self, stop_future, stop_condition),
|(xmpp, stop_future, mut stop_condition)| {
// ToDo: check timeouts if iqs

let XmppConnection {
state: XmppState { client, mut data },
account,
} = xmpp;

if let Some(send_element) = data.send_queue.pop_front() {
use tokio::prelude::Sink;

info!("Sending {}", String::from(&send_element));
Box::new(
client
.send(Packet::Stanza(send_element))
.select2(stop_future)
.then(move |r| match r {
Ok(Either::A((client, b))) => {
Box::new(future::ok(future::Loop::Continue((
XmppConnection {
state: XmppState { client, data },
account,
},
b,
stop_condition,
))))
as Box<dyn Future<Item = _, Error = _>>
}
Ok(Either::B((t, a))) => Box::new(a.then(|r| match r {
Ok(client) => future::ok(future::Loop::Break((
XmppConnection {
state: XmppState { client, data },
account,
},
Ok(Either::B(t)),
))),
Err(se) => {
warn!("XMPP sending error: {}", se);
future::err((account, Ok(Either::B(t))))
}
})),
Err(Either::A((e, b))) => {
warn!("XMPP sending error: {}", e);
Box::new(future::err((account, Ok(Either::A(b)))))
}
Err(Either::B((e, a))) => Box::new(a.then(|r| match r {
Ok(client) => future::ok(future::Loop::Break((
XmppConnection {
state: XmppState { client, data },
account,
},
Err(e),
))),
Err(se) => {
warn!("XMPP sending error: {}", se);
future::err((account, Err(e)))
}
})),
}),
) as Box<dyn Future<Item = _, Error = _>>
} else {
Box::new(
client
.into_future()
.select2(stop_future)
.then(move |r| match r {
Ok(Either::A(((event, client), b))) => {
if let Some(event) = event {
let mut xmpp = XmppConnection {
state: XmppState { client, data },
account,
};

if xmpp.xmpp_processing(&event) {
match stop_condition(&mut xmpp, event) {
Ok(true) => future::ok(future::Loop::Break((
xmpp,
Ok(Either::A(b)),
))),
Ok(false) => future::ok(future::Loop::Continue((
xmpp,
b,
stop_condition,
))),
Err(_e) => {
future::err((xmpp.account, Ok(Either::A(b))))
}
}
} else {
future::err((xmpp.account, Ok(Either::A(b))))
}
} else {
future::err((account, Ok(Either::A(b))))
}
}
Ok(Either::B((t, a))) => {
if let Some(client) = a.into_inner() {
future::ok(future::Loop::Break((
XmppConnection {
state: XmppState { client, data },
account,
},
Ok(Either::B(t)),
)))
} else {
future::err((account, Ok(Either::B(t))))
}
}
Err(Either::A((e, b))) => {
warn!("XMPP error: {}", e.0);
future::err((account, Ok(Either::A(b))))
}
Err(Either::B((e, a))) => {
if let Some(client) = a.into_inner() {
future::ok(future::Loop::Break((
XmppConnection {
state: XmppState { client, data },
account,
},
Err(e),
)))
} else {
future::err((account, Err(e)))
}
}
}),
)
}
},
)
}

/// get connection and wait for online status and set presence
/// returns error if something went wrong and xmpp connection is broken
fn online(&mut self, event: Event) -> Result<bool, ()> {
match event {
Event::Online => {
info!("Online!");
Ok(true)
}
Event::Stanza(s) => {
warn!("Stanza before online: {}", String::from(&s));
Ok(false)
}
_ => {
error!("Disconnected while online");
Err(())
}
}
}

fn initial_roster<F, E>(
self,
stop_future: F,
) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>>
where
F: Future<Error = E> + 'static,
E: 'static,
{
let XmppConnection {
account,
state: XmppState { client, mut data },
} = self;
use tokio::prelude::Sink;

data.counter += 1;
let id_init_roster = format!("id_init_roster{}", data.counter);
let get_roster = stanzas::make_get_roster(&id_init_roster);
let account2 = account.clone();
info!("Quering roster... {}", String::from(&get_roster));
data.pending_ids.insert(
id_init_roster.clone(),
(
Instant::now() + Duration::from_secs(60),
Box::new(InitRosterIqHandler {}),
),
);

client
.send(Packet::Stanza(get_roster))
.map_err(move |e| {
error!("Error on querying roster: {}", e);
account2
})
.and_then(move |client| {
XmppConnection {
state: XmppState { client, data },
account,
}
.processing(move |conn, _| Ok(conn.state.data.roster_init), stop_future)
.map_err(|(account, _)| account)
.and_then(|(conn, r)| match r {
Ok(Either::A(_)) => future::ok(conn),
Ok(Either::B(_)) => future::err(conn.account),
Err(_e) => future::err(conn.account),
})
})
}

fn self_presence<F, E>(
self,
stop_future: F,
) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>>
where
F: Future<Error = E> + 'static,
E: Into<failure::Error> + 'static,
{
let XmppConnection {
account,
state: XmppState { client, data },
} = self;
use tokio::prelude::Sink;

let presence = stanzas::make_presence(&account);
let account2 = account.clone();
info!("Sending presence... {}", String::from(&presence));

client
.send(Packet::Stanza(presence))
.map_err(|e| {
error!("Error on send self-presence: {}", e);
account2
})
.and_then(move |client| {
XmppConnection {
state: XmppState { client, data },
account,
}
.processing(
move |conn, _| Ok(conn.state.data.self_presence),
stop_future,
)
.map_err(|(account, _)| account)
.and_then(|(conn, r)| match r {
Ok(Either::A(_)) => future::ok(conn),
Ok(Either::B(_)) => future::err(conn.account),
Err(_e) => future::err(conn.account),
})
})
}

fn process_jid(&mut self, xmpp_to: &xmpp_parsers::Jid) {
if let Some(ref mut mailbox) = self.state.data.outgoing_mailbox.get_mut(xmpp_to) {
if !mailbox.is_empty() {
if let Some(ref mut rdata) = self.state.data.roster.get_mut(xmpp_to) {
info!("Jid {} in roster", xmpp_to);
let sub_to = match rdata.0 {
xmpp_parsers::roster::Subscription::To => true,
xmpp_parsers::roster::Subscription::Both => true,
_ => false,
};
if sub_to {
info!("Subscribed to {}", xmpp_to);
self.state.data.send_queue.extend(
mailbox.drain(..).map(|message| {
stanzas::make_chat_message(xmpp_to.clone(), message)
}),
);
} else if rdata.1 == xmpp_parsers::roster::Ask::None {
info!("Not subscribed to {}", xmpp_to);
self.state
.data
.send_queue
.push_back(stanzas::make_ask_subscribe(xmpp_to.clone()));
}
let sub_from = match rdata.0 {
xmpp_parsers::roster::Subscription::From => true,
xmpp_parsers::roster::Subscription::Both => true,
_ => false,
};
if !sub_from {
info!("Not subscription from {}", xmpp_to);
self.state
.data
.send_queue
.push_back(stanzas::make_allow_subscribe(xmpp_to.clone()));
}
} else {
info!("Jid {} not in roster", xmpp_to);

self.state.data.counter += 1;
let id_add_roster = format!("id_add_roster{}", self.state.data.counter);
let add_roster = stanzas::make_add_roster(&id_add_roster, xmpp_to.clone());
info!("Adding jid {} to roster id {}", xmpp_to, id_add_roster);
self.state.data.pending_ids.insert(
id_add_roster,
(
Instant::now() + Duration::from_secs(60),
Box::new(AddRosterIqHandler {
jid: xmpp_to.clone(),
}),
),
);
self.state.data.send_queue.push_back(add_roster);
}
}
}
}

pub fn process_command(&mut self, cmd: XmppCommand) {
info!("Got command");
match cmd {
XmppCommand::Chat { xmpp_to, message } => {
self.state
.data
.outgoing_mailbox
.entry(xmpp_to.clone())
.or_default()
.push(message);
self.process_jid(&xmpp_to);
}
XmppCommand::Chatroom { muc_id, message } => {
if let Some(muc) = self.state.data.mucs.get(&muc_id) {
self.state
.data
.send_queue
.push_back(stanzas::make_muc_message(muc.clone(), message));
} else {
error!("Not found MUC {}", muc_id);
}
}
XmppCommand::Ping => {
self.state.data.counter += 1;
let id_ping = format!("id_ping{}", self.state.data.counter);
let ping = stanzas::make_ping(&id_ping, self.state.client.jid.clone());
self.state.data.send_queue.push_back(ping);
self.state.data.pending_ids.insert(
id_ping,
(
Instant::now() + Duration::from_secs(30),
Box::new(PingIqHandler {}),
),
);
}
XmppCommand::TimeoutCleanup => {
let now = Instant::now();
let timeouted: Vec<String> = self
.state
.data
.pending_ids
.iter()
.filter_map(|(id, (timeout, _))| {
if now >= *timeout {
Some(id.to_string())
} else {
None
}
})
.collect();
let mut correct = true;
timeouted.into_iter().for_each(|id| {
if let Some((_, handler)) = self.state.data.pending_ids.remove(&id) {
correct &= handler.timeout(&mut self);
}
})
}
}
}

pub fn shutdown(self) -> impl Future<Item = (), Error = failure::Error> {
info!("Shutdown connection");
let XmppConnection { account, state } = self;
stream::iter_ok(
state
.data
.mucs
.values()
.map(std::clone::Clone::clone)
.collect::<Vec<_>>(),
)
.fold(state, move |XmppState { client, data }, muc_jid| {
let muc_presence =
stanzas::make_muc_presence_leave(account.jid.clone(), muc_jid.clone());

info!(
"Sending muc leave presence... {}",
String::from(&muc_presence)
);
use tokio::prelude::Sink;
client
.send(Packet::Stanza(muc_presence))
.map_err(|e| {
error!("Error on send muc presence: {}", e);
e
})
.and_then(|client| future::ok(XmppState { client, data }))
})
.map(|_| ())
}

fn enter_mucs<F, E>(
self,
_stop_future: F,
) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>>
where
F: Future<Error = E> + 'static,
E: Into<failure::Error> + 'static,
{
let XmppConnection { account, state } = self;

let account2 = account.clone();
let account3 = account.clone();

stream::iter_ok(account.chatrooms.clone())
.fold(state, move |XmppState { client, mut data }, muc_jid| {
data.counter += 1;
let id_muc_presence = format!("id_muc_presence{}", data.counter);
let muc_presence = stanzas::make_muc_presence(
&id_muc_presence,
account2.jid.clone(),
muc_jid.1.clone(),
);

info!("Sending muc presence... {}", String::from(&muc_presence));

let account4 = account2.clone();

use tokio::prelude::Sink;
client
.send(Packet::Stanza(muc_presence))
.map_err(|e| {
error!("Error on send muc presence: {}", e);
account4
})
.and_then(|client| {
data.mucs.insert(muc_jid.0, muc_jid.1);
future::ok(XmppState { client, data })
})
})
.map(|state| XmppConnection {
account: account3,
state,
})
}
}
replacement in src/xmpp/stanzas.rs at line 0

[3.13]→[2.34147:34168](∅→∅)

use config::Account;

[3.13]

[3.35]

use crate::config::Account;
edit in src/xmpp/stanzas.rs at line 2

[3.57]

[3.57]

use xmpp_parsers::iq::Iq;
use xmpp_parsers::message::{Body, Message, MessageType};
use xmpp_parsers::ping::Ping;
edit in src/xmpp/stanzas.rs at line 6

[3.141]

[3.141]

use xmpp_parsers::roster::{Item, Roster};
use xmpp_parsers::stanza_error::{DefinedCondition, ErrorType, StanzaError};
edit in src/xmpp/stanzas.rs at line 15

[3.397]

[3.1413]

presence.into()
}

pub fn make_get_roster(id: &str) -> Element {
Iq::from_get(
id,
Roster {
items: vec![],
ver: None,
},
)
.into()
}

pub fn make_add_roster(id: &str, jid: xmpp_parsers::Jid) -> Element {
Iq::from_set(
id,
Roster {
items: vec![Item {
jid,
name: None,
subscription: xmpp_parsers::roster::Subscription::None,
ask: xmpp_parsers::roster::Ask::None,
groups: vec![],
}],
ver: None,
},
)
.into()
}

pub fn make_roster_push_answer(
id: String,
from: xmpp_parsers::Jid,
to: Option<xmpp_parsers::Jid>,
) -> Iq {
let mut answer = Iq::from_result(id, None as Option<Roster>);
answer.from = Some(from);
answer.to = to;
answer
}

pub fn make_ask_subscribe(jid: xmpp_parsers::Jid) -> Element {
let mut presence = Presence::new(PresenceType::Subscribe);
presence.to = Some(jid);
presence.into()
}

pub fn make_allow_subscribe(jid: xmpp_parsers::Jid) -> Element {
let mut presence = Presence::new(PresenceType::Subscribed);
presence.to = Some(jid);
presence.into()
}

pub fn make_chat_message(jid: xmpp_parsers::Jid, text: String) -> Element {
let mut message = Message::new(Some(jid));
message.bodies.insert(String::new(), Body(text));
message.type_ = MessageType::Chat;
message.into()
}

pub fn make_muc_presence(id: &str, from: xmpp_parsers::Jid, to: xmpp_parsers::Jid) -> Element {
let mut presence = Presence::new(PresenceType::None);
presence.from = Some(from);
presence.to = Some(to);
presence.id = Some(id.to_string());
presence.add_payload(xmpp_parsers::muc::Muc::new());
edit in src/xmpp/stanzas.rs at line 84

[3.1435]

pub fn make_muc_message(to: xmpp_parsers::Jid, text: String) -> Element {
let mut message = Message::new(Some(to.into_bare_jid()));
message.bodies.insert(String::new(), Body(text));
message.type_ = MessageType::Groupchat;
message.into()
}

pub fn make_muc_presence_leave(from: xmpp_parsers::Jid, to: xmpp_parsers::Jid) -> Element {
let mut presence = Presence::new(PresenceType::Unavailable);
presence.from = Some(from);
presence.to = Some(to);
presence.into()
}

pub fn make_ping(id: &str, from: xmpp_parsers::Jid) -> Element {
let mut ping = Iq::from_get(id, Ping);
ping.to = Some(from.clone().into_domain_jid());
ping.from = Some(from);
ping.into()
}

pub fn make_pong(id: &str, from: xmpp_parsers::Jid, to: Option<xmpp_parsers::Jid>) -> Iq {
let mut pong = Iq::from_result(id, None as Option<Roster>);
pong.from = Some(from);
pong.to = to;
pong
}

pub fn make_iq_unsupported_error(
id: String,
from: xmpp_parsers::Jid,
to: Option<xmpp_parsers::Jid>,
) -> Iq {
let mut error = Iq::from_error(
id,
StanzaError {
type_: ErrorType::Cancel,
by: Some(from.clone()),
defined_condition: DefinedCondition::ServiceUnavailable,
texts: std::collections::BTreeMap::new(),
other: None,
},
);
error.from = Some(from);
error.to = to;
error
}
replacement in src/xmpp/mod.rs at line 0

[3.17]→[2.34169:34213](∅→∅)

use tokio::prelude::future::{self, Either};

[3.17]

[3.62]

use tokio::prelude::future::{self, Either, Future};
edit in src/xmpp/mod.rs at line 2

[3.90]→[2.34214:34252](∅→∅)

use tokio::prelude::{Future, Stream};
replacement in src/xmpp/mod.rs at line 3

[3.198]→[2.34253:34286](∅→∅)

use tokio_xmpp::{Client, Event};

[3.198]

[3.296]

use crate::config;
replacement in src/xmpp/mod.rs at line 5

[3.297]→[2.34287:34299](∅→∅)

use config;

[3.297]

[3.3355]

mod element_processor;
edit in src/xmpp/mod.rs at line 8

[3.29460]→[2.34300:34645](∅→∅),[2.34645]→[3.56289:56290](∅→∅),[3.56289]→[3.56289:56290](∅→∅),[3.56290]→[2.34646:35606](∅→∅),[2.35606]→[3.58159:58160](∅→∅),[3.29606]→[3.58159:58160](∅→∅),[3.58159]→[3.58159:58160](∅→∅),[3.58160]→[2.35607:36004](∅→∅),[3.8035]→[3.3816:3817](∅→∅),[3.34856]→[3.3816:3817](∅→∅),[3.13873]→[3.3816:3817](∅→∅),[3.5745]→[3.3816:3817](∅→∅),[3.24]→[3.3816:3817](∅→∅),[3.9716]→[3.3816:3817](∅→∅),[3.4055]→[3.3816:3817](∅→∅),[2.36004]→[3.3816:3817](∅→∅),[3.8486]→[3.3816:3817](∅→∅),[3.317]→[3.3816:3817](∅→∅),[3.4021]→[3.3816:3817](∅→∅),[3.23285]→[3.3816:3817](∅→∅),[3.4848]→[3.3816:3817](∅→∅),[3.52]→[3.3816:3817](∅→∅),[3.3569]→[3.3816:3817](∅→∅),[3.403]→[3.3816:3817](∅→∅),[3.52]→[3.3816:3817](∅→∅),[3.8743]→[3.3816:3817](∅→∅),[3.77]→[3.3816:3817](∅→∅),[3.3150]→[3.3816:3817](∅→∅),[3.23335]→[3.3816:3817](∅→∅),[3.3816]→[3.3816:3817](∅→∅),[3.3817]→[2.36005:37511](∅→∅)

pub struct XmppConnection {
account: std::rc::Rc<config::Account>,
inner: Option<(stream::SplitSink<Client>, stream::SplitStream<Client>)>,
}

impl XmppConnection {
fn new(account: config::Account) -> XmppConnection {
XmppConnection {
account: std::rc::Rc::new(account),
inner: None,
}
}

/// connects if nothing connected
/// Error shoud be !
fn connect<E: 'static>(self) -> impl Future<Item = Self, Error = E> {
info!("xmpp connection...");
let XmppConnection { account, inner } = self;

if let Some(inner) = inner {
Box::new(future::ok(XmppConnection {
account,
inner: Some(inner),
})) as Box<Future<Item = _, Error = E>>
} else {
Box::new(future::loop_fn(account, |account| {
info!("xmpp initialization...");
let mut res_client = Client::new(&account.jid, &account.password);
while let Err(e) = res_client {
error!("Cann't init xmpp client: {}", e);
res_client = Client::new(&account.jid, &account.password);
}
let client = res_client.expect("Cann't init xmpp client");
info!("xmpp initialized");

// future to wait for online
Self::online(client.split(), account)
.and_then(Self::self_presence)
.then(|r| match r {
Ok(conn) => future::ok(future::Loop::Break(conn)),
Err(acc) => future::ok(future::Loop::Continue(acc)),
})
}))
}
}

/// get connection and wait for online status and set presence
/// returns error if something went wrong
fn online(
(sink, stream): (stream::SplitSink<Client>, stream::SplitStream<Client>),
account: std::rc::Rc<config::Account>,
) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>> {
Box::new(future::loop_fn(
(sink, stream, account),
|(sink, stream, account)| {
stream.into_future().then(|r| match r {
Ok((event, stream)) => match event {
Some(Event::Online) => {
info!("Online");
future::ok(future::Loop::Break(XmppConnection {
account,
inner: Some((sink, stream)),
}))
}
Some(Event::Stanza(s)) => {
info!("xmpp stanza: {:?}", s);
future::ok(future::Loop::Continue((sink, stream, account)))
}
_ => {
warn!("Disconnected");
future::err(account)
}
},
Err((e, _)) => {
error!("xmpp receive error: {}", e);
future::err(account)
}
})
},
))
}
replacement in src/xmpp/mod.rs at line 9

[2.37512]→[2.37512:37745](∅→∅)

fn self_presence(self) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>> {
let XmppConnection { account, inner } = self;
if let Some((sink, stream)) = inner {
use tokio::prelude::Sink;

[2.37512]

[2.37745]

mod xmpp_connection;
use xmpp_connection::MaybeXmppConnection;
replacement in src/xmpp/mod.rs at line 12

[2.37746]→[2.37746:40647](∅→∅)

let presence = stanzas::make_presence(&account);
info!("Sending presence...");
Box::new(
sink.send(presence)
.map_err(|e| {
error!("Error on send self-presence: {}", e);
"Cann't send self-presence".to_owned()
}).join(
future::loop_fn((account.clone(), stream), |(account, stream)| {
stream
.into_future()
.map_err(|(e, _)| {
error!("Error on reading self-presence: {}", e);
"Cann't read self-presence".to_owned()
}).and_then(|(event, stream)| match event {
Some(event) => {
if let tokio_xmpp::Event::Stanza(e) = event {
info!("Get stanza: {:?}", e);
if e.name() == "presence"
&& e.attr("from")
.map_or(false, |f| f == account.jid)
&& e.attr("to").map_or(false, |f| f == account.jid)
{
info!("Self presence");
future::ok(future::Loop::Break(stream))
} else {
future::ok(future::Loop::Continue((
account, stream,
)))
}
} else {
future::err("Got wrong event".to_owned())
}
}
None => future::err("Got closed stream".to_owned()),
})
}).map_err(|e| format!("waiting self-presence: {}", e)),
).then(|r| match r {
Err(e) => {
error!("Self-presence waiting error: {}", e);
future::err(account)
}
Ok(inner) => future::ok(XmppConnection {
account,
inner: Some(inner),
}),
}),
)
} else {
warn!("Don't gen connection on self-presence");
Box::new(future::err(account)) as Box<Future<Item = _, Error = _>>
}
}
}

[2.37746]

[2.40647]

pub use xmpp_connection::XmppCommand;
replacement in src/xmpp/mod.rs at line 14

[2.40648]→[2.40648:40715](∅→∅)

#[derive(Debug)]
pub struct XmppCommand;

struct XmppState<F, S> {

[2.40648]

[3.86]

struct XmppProcessState<F, S> {
replacement in src/xmpp/mod.rs at line 17

[3.3891]→[2.40716:40742](∅→∅)

conn: XmppConnection,

[3.3891]

[3.3917]

conn: MaybeXmppConnection,
replacement in src/xmpp/mod.rs at line 20

[3.3920]→[2.40743:40870](∅→∅)

impl<F, S> XmppState<F, S> {
fn new(cmd_recv: S, signal: F, conn: XmppConnection) -> XmppState<F, S> {
XmppState {

[3.3920]

[3.4058]

impl<F, S> XmppProcessState<F, S> {
fn new(cmd_recv: S, signal: F, conn: MaybeXmppConnection) -> XmppProcessState<F, S> {
XmppProcessState {
replacement in src/xmpp/mod.rs at line 34

[3.4243]→[2.40871:40933](∅→∅)

) -> impl future::Future<Item = (), Error = tokio::io::Error>

[3.4243]

[3.4305]

) -> impl future::Future<Item = (), Error = failure::Error>
replacement in src/xmpp/mod.rs at line 36

[3.4311]→[2.40934:41030](∅→∅)

F: future::Future<Item = ()> + 'static,
S: stream::Stream<Item = XmppCommand> + 'static

[3.4311]

[3.4355]

F: future::Future + Clone + 'static,
<F as hyper::rt::Future>::Error: std::fmt::Display + Into<failure::Error> + Send,
S: stream::Stream<Item = XmppCommand> + 'static,
replacement in src/xmpp/mod.rs at line 40

[3.4357]→[2.41031:41154](∅→∅)

let signal = signal
.map_err(|_| tokio::io::Error::new(tokio::io::ErrorKind::Other, "Wrong shutdown signal"));

[3.4357]

[2.41154]

let conn = account.into();
replacement in src/xmpp/mod.rs at line 42

[2.41155]→[2.41155:41200](∅→∅),[3.6018]→[3.4526:4527](∅→∅),[3.5898]→[3.4526:4527](∅→∅),[3.4176]→[3.4526:4527](∅→∅),[3.6085]→[3.4526:4527](∅→∅),[3.6304]→[3.4526:4527](∅→∅),[3.5689]→[3.4526:4527](∅→∅),[2.41200]→[3.4526:4527](∅→∅),[3.4188]→[3.4526:4527](∅→∅),[3.5915]→[3.4526:4527](∅→∅),[3.648]→[3.4526:4527](∅→∅),[3.23504]→[3.4526:4527](∅→∅),[3.5058]→[3.4526:4527](∅→∅),[3.4946]→[3.4526:4527](∅→∅),[3.12431]→[3.4526:4527](∅→∅),[3.9038]→[3.4526:4527](∅→∅),[3.4526]→[3.4526:4527](∅→∅),[3.4527]→[2.41201:41291](∅→∅)

let conn = XmppConnection::new(account);

future::loop_fn(XmppState::new(cmd_recv, signal, conn), |s| {
let XmppState {

[2.41155]

[3.4617]

future::loop_fn(XmppProcessState::new(cmd_recv, signal, conn), |s| {
let XmppProcessState {
replacement in src/xmpp/mod.rs at line 48

[3.4692]→[2.41292:43921](∅→∅)

signal
.select2(conn.connect().and_then(|conn| {
info!("xmpp connected!");
cmd_recv
.into_future()
.map_err(|_| {
error!("Got error on recv cmd");
tokio::io::Error::new(tokio::io::ErrorKind::Other, "Receive cmd error")
}).map(|f| (f, conn))
})).then(|r| {
match r {
Ok(Either::A((_x, b))) => {
info!("Got signal");
// got signal, breaks
Box::new(b.map(|b| future::Loop::Break((Some((b.0).1), b.1))))
as Box<Future<Item = _, Error = _>>
}
Ok(Either::B((x, a))) => {
info!("Got cmd");
// got cmd, continue
Box::new(future::ok(future::Loop::Continue(XmppState::new(
(x.0).1,
a,
x.1,
)))) as Box<Future<Item = _, Error = _>>
}
Err(Either::A((e, b))) => {
// got signal error, breaks
error!("Signal error: {}", e);
Box::new(b.map(|b| future::Loop::Break((Some((b.0).1), b.1))))
as Box<Future<Item = _, Error = _>>
}
Err(Either::B((e, _a))) => {
// got cmd error, its bad
error!("Cmd error: {}", e);
Box::new(future::err(tokio::io::Error::new(
tokio::io::ErrorKind::Other,
"Cmd error",
))) as Box<Future<Item = _, Error = _>>
}
}
})
}).and_then(
|(opt_cmd_recv, _conn): (Option<S>, XmppConnection)| {
if let Some(cmd_recv) = opt_cmd_recv {
// process left commands
info!("Stop accepting commands");
Box::new(cmd_recv.for_each(|_cmd| future::ok(())).map_err(|_| {
tokio::io::Error::new(tokio::io::ErrorKind::Other, "cmd receiver last error")
})) as Box<Future<Item = (), Error = tokio::io::Error>>
} else {
Box::new(future::err(tokio::io::Error::new(
tokio::io::ErrorKind::Other,
"cmd receiver gone",
)))
}
},
)

[3.4692]

[3.7379]

conn.connect(signal.clone()).and_then(|conn| {
info!("xmpp connected!");
conn.processing(|_, _| Ok(false), cmd_recv.into_future())
.then(|r| match r {
Ok((mut conn, r)) => match r {
Ok(Either::A(f)) => {
if let Some(cmd_recv) = f.into_inner() {
future::ok(future::Loop::Continue(XmppProcessState {
cmd_recv,
signal,
conn: conn.into(),
}))
} else {
error!("Command receiver is gone");
future::ok(future::Loop::Break(Some(conn)))
}
}
Ok(Either::B((cmd, cmd_recv))) => {
if let Some(cmd) = cmd {
conn.process_command(cmd);

future::ok(future::Loop::Continue(XmppProcessState {
cmd_recv,
signal,
conn: conn.into(),
}))
} else {
future::ok(future::Loop::Break(Some(conn)))
}
}
Err(_) => {
error!("Command receiver is broken");
future::ok(future::Loop::Break(Some(conn)))
}
},
Err((account, r)) => match r {
Ok(Either::A(f)) => {
if let Some(cmd_recv) = f.into_inner() {
future::ok(future::Loop::Continue(XmppProcessState {
cmd_recv,
signal,
conn: account.into(),
}))
} else {
future::err(format_err!("Command receiver is gone"))
}
}
Ok(Either::B((cmd, cmd_recv))) => {
if let Some(_cmd) = cmd {
error!("Xmpp connection broken while get command");
future::ok(future::Loop::Continue(XmppProcessState {
cmd_recv,
signal,
conn: account.into(),
}))
} else {
future::ok(future::Loop::Break(None))
}
}
Err(_) => future::err(format_err!("Command receiver is broken")),
},
})
})
})
.and_then(|opt_conn| {
if let Some(conn) = opt_conn {
Box::new(conn.shutdown()) as Box<dyn Future<Item = (), Error = _>>
} else {
Box::new(future::ok(()))
}
})
replacement in src/xmpp/element_processor.rs at line 0

[3.11301]→[2.43922:45019](∅→∅)

type Func<S, T, E> = dyn Fn(&mut S, E) -> T + Sync;

pub struct Processor<S: 'static, T: 'static, E: Clone + 'static> {
processors: Vec<Box<Func<S, Option<T>, E>>>,
default: &'static Func<S, T, E>,
}

impl<S: 'static, T: 'static, E: Clone + 'static> Processor<S, T, E> {
pub fn new<F>(f: &'static F) -> Processor<S, T, E>
where
F: Fn(&mut S, E) -> T + Sync + 'static,
{
Processor {
processors: vec![],
default: f,
}
}

pub fn register<F, A>(&mut self, f: &'static F)
where
F: Fn(&mut S, A) -> T + Sync + 'static,
A: std::convert::TryFrom<E>,
{
self.processors.push(Box::new(move |s, e: E| {
use std::convert::TryInto;
(e.try_into().ok() as Option<A>).map(|a| f(s, a))
}));
}

pub fn process(&self, s: &mut S, e: E) -> T {
for processor in self.processors.iter() {
match processor(s, e.clone()) {
Some(t) => return t,
None => continue,
}
}
(*self.default)(s, e)
}
}

[3.11301]

type Func<S, T, E> = dyn Fn(&mut S, E) -> T + Sync;

pub struct Processor<S: 'static, T: 'static, E: Clone + 'static> {
processors: Vec<Box<Func<S, Option<T>, E>>>,
default: &'static Func<S, T, E>,
}

impl<S: 'static, T: 'static, E: Clone + 'static> Processor<S, T, E> {
pub fn new<F>(f: &'static F) -> Processor<S, T, E>
where
F: Fn(&mut S, E) -> T + Sync + 'static,
{
Processor {
processors: vec![],
default: f,
}
}

pub fn register<F, A>(&mut self, f: &'static F)
where
F: Fn(&mut S, A) -> T + Sync + 'static,
A: std::convert::TryFrom<E>,
{
self.processors.push(Box::new(move |s, e: E| {
use std::convert::TryInto;
(e.try_into().ok() as Option<A>).map(|a| f(s, a))
}));
}

pub fn process(&self, s: &mut S, e: E) -> T {
for processor in self.processors.iter() {
match processor(s, e.clone()) {
Some(t) => return t,
None => continue,
}
}
(*self.default)(s, e)
}
}
edit in src/stoppable_receiver.rs at line 0

[3.450]

[3.473]

use std::fmt::Debug;
edit in src/stoppable_receiver.rs at line 17

[3.755]

[3.769]

T: Debug,
replacement in src/stoppable_receiver.rs at line 37

[3.1292]→[2.45020:45050](∅→∅)

self.receiver.poll();

[3.1292]

[3.1322]

self.receiver.poll()
edit in src/stoppable_receiver.rs at line 44

[3.1445]

[3.1459]

T: Debug,
edit in src/main.rs at line 2

[3.40861]

[3.40890]

#![deny(bare_trait_objects)]
edit in src/main.rs at line 8

[3.40955]→[2.45051:45073](∅→∅)

extern crate minidom;
edit in src/main.rs at line 17

[3.41151]

[3.41186]

#[macro_use]
extern crate failure;
edit in src/main.rs at line 21

[3.41232]

[3.41232]

#[macro_use]
extern crate lazy_static;
edit in src/main.rs at line 24

[3.41233]→[2.45074:45106](∅→∅)

use hyper::service::service_fn;
replacement in src/main.rs at line 29

[3.41346]→[2.45107:45133](∅→∅)

use tokio::prelude::Sink;

[3.41346]

[3.41390]

use tokio::prelude::{Future, Sink, Stream};
replacement in src/main.rs at line 32

[3.41403]→[2.45134:45154](∅→∅)

use config::Config;

[3.41403]

[3.41430]

use crate::config::Config;
replacement in src/main.rs at line 35

[3.41441]→[2.45155:45194](∅→∅)

use xmpp::{xmpp_process, XmppCommand};

[3.41441]

[3.41487]

use crate::xmpp::{xmpp_process, XmppCommand};
replacement in src/main.rs at line 38

[3.41512]→[2.45195:45234](∅→∅)

use stoppable_receiver::stop_receiver;

[3.41512]

[3.48631]

use crate::stoppable_receiver::stop_receiver;

fn body_to_string(req: Request<Body>) -> impl Future<Item = String, Error = failure::Error> {
req.into_body()
.map_err(std::convert::Into::into)
.fold(String::new(), |mut acc, ch| {
std::str::from_utf8(&*ch).map(|s| {
acc.push_str(s);
acc
})
})
}

struct ServiceCmd {
cmd_send: tokio_channel::mpsc::Sender<XmppCommand>,
}

impl hyper::service::Service for ServiceCmd {
type ReqBody = Body;
type ResBody = Body;
type Error = failure::Error;
type Future =
Box<dyn Future<Item = Response<Self::ResBody>, Error = Self::Error> + Send + 'static>;

fn call(&mut self, req: Request<Self::ReqBody>) -> Self::Future {
let xmpp_to_opt = req.headers().get("X-XMPP-To");
let xmpp_to_res: Result<xmpp_parsers::Jid, failure::Error> = xmpp_to_opt.map_or_else(
|| Err(format_err!("No X-XMPP-To header")),
|xmpp_to| {
std::str::from_utf8(xmpp_to.as_bytes())
.map_err(std::convert::Into::into)
.and_then(|s| std::str::FromStr::from_str(s).map_err(std::convert::Into::into))
},
);

let xmpp_muc_opt = req
.headers()
.get("X-XMPP-Muc")
.map(|h| h.to_str().map(std::string::ToString::to_string));

match (xmpp_muc_opt, xmpp_to_res) {
(None, Err(err)) => {
warn!("Unknown destination: {}", err);
Box::new(tokio::prelude::future::result(
Response::builder()
.status(hyper::StatusCode::BAD_REQUEST)
.body(Body::from(format!("Unknown destination: {}", err)))
.map_err(std::convert::Into::into),
)) as Box<dyn Future<Item = _, Error = _> + Send + 'static>
}
(None, Ok(xmpp_to)) => {
info!("Got request. Reading body...");
let cmd_send = self.cmd_send.clone();
Box::new(body_to_string(req).and_then(move |message: String| {
if !message.is_empty() {
Box::new(
cmd_send
.clone()
.send(XmppCommand::Chat { xmpp_to, message })
.then(|r| match r {
Ok(_) => tokio::prelude::future::ok(Response::new(Body::from(
"Accepted",
))),
Err(e) => {
error!("Command sent error: {}", e);
tokio::prelude::future::result(
Response::builder()
.status(hyper::StatusCode::BAD_REQUEST)
.body(Body::from(format!(
"Command sent error: {}",
e
))),
)
}
})
.map_err(std::convert::Into::into),
)
} else {
warn!("Empty message");
Box::new(tokio::prelude::future::result(
Response::builder()
.status(hyper::StatusCode::BAD_REQUEST)
.body(Body::from("Empty message"))
.map_err(std::convert::Into::into),
))
as Box<dyn Future<Item = _, Error = _> + Send + 'static>
}
})) as Box<dyn Future<Item = _, Error = _> + Send + 'static>
}
(Some(Ok(muc_id)), _) => {
info!("Got MUC request. Reading body...");
let cmd_send = self.cmd_send.clone();
Box::new(body_to_string(req).and_then(move |message: String| {
if !message.is_empty() {
Box::new(
cmd_send
.clone()
.send(XmppCommand::Chatroom { muc_id, message })
.then(|r| match r {
Ok(_) => tokio::prelude::future::ok(Response::new(Body::from(
"Accepted",
))),
Err(e) => {
error!("Command sent error: {}", e);
tokio::prelude::future::result(
Response::builder()
.status(hyper::StatusCode::BAD_REQUEST)
.body(Body::from(format!(
"Command sent error: {}",
e
))),
)
}
})
.map_err(std::convert::Into::into),
)
} else {
warn!("Empty message");
Box::new(tokio::prelude::future::result(
Response::builder()
.status(hyper::StatusCode::BAD_REQUEST)
.body(Body::from("Empty message"))
.map_err(std::convert::Into::into),
))
as Box<dyn Future<Item = _, Error = _> + Send + 'static>
}
})) as Box<dyn Future<Item = _, Error = _> + Send + 'static>
}
(Some(Err(err)), _) => {
warn!("Unknown MUC destination: {}", err);
Box::new(tokio::prelude::future::result(
Response::builder()
.status(hyper::StatusCode::BAD_REQUEST)
.body(Body::from(format!("Unknown MUC destination: {}", err)))
.map_err(std::convert::Into::into),
)) as Box<dyn Future<Item = _, Error = _> + Send + 'static>
}
}
}
}

struct MakeServiceCmd {
cmd_send: tokio_channel::mpsc::Sender<XmppCommand>,
}

impl<Ctx> hyper::service::MakeService<Ctx> for MakeServiceCmd {
type ReqBody = Body;
type ResBody = Body;
type Error = failure::Error;
type Service = ServiceCmd;
type Future = tokio::prelude::future::FutureResult<ServiceCmd, Self::MakeError>;
type MakeError = hyper::http::Error;
edit in src/main.rs at line 191

[3.48632]

[3.18]

fn make_service(&mut self, _ctx: Ctx) -> Self::Future {
tokio::prelude::future::ok(ServiceCmd {
cmd_send: self.cmd_send.clone(),
})
}
}
replacement in src/main.rs at line 211

[3.49182]→[2.45235:45260](∅→∅)

).get_matches();

[3.49182]

[3.49216]

)
.get_matches();
replacement in src/main.rs at line 214

[3.49217]→[2.45261:45349](∅→∅)

let config = Config::new(args.value_of("config").expect("Mandatory option config"))

[3.49217]

[3.49306]

let config = Config::read(args.value_of("config").expect("Mandatory option config"))
replacement in src/main.rs at line 222

[3.49498]→[2.45350:45416](∅→∅)

.map_err(|e| error!("Cann't get CTRL+C signal: {}", e.0))

[3.49498]

[3.49605]

.map_err(|e| {
error!("Cann't get CTRL+C signal: {}", e.0);
e.0
})
replacement in src/main.rs at line 231

[3.49740]→[2.45417:46248](∅→∅)

.serve(move || {
let cmd_send = cmd_send.clone();
service_fn(move |_req: Request<Body>| {
info!("Got request");
cmd_send.clone().send(XmppCommand {}).then(|r| match r {
Ok(_) => tokio::prelude::future::ok(Response::new(Body::from("Accepted"))),
Err(e) => {
error!("Command sent error: {}", e);
tokio::prelude::future::result(
Response::builder()
.status(hyper::StatusCode::BAD_REQUEST)
.body(Body::from(format!("Command sent error: {}", e))),
)
}
})
})
}).with_graceful_shutdown(ctrl_c.clone().map(|_| ()))

[3.49740]

[3.49883]

.serve(MakeServiceCmd {
cmd_send: cmd_send.clone(),
})
.with_graceful_shutdown(ctrl_c.clone().map(|_| ()))
edit in src/main.rs at line 239

[3.50000]

[3.50812]

if let Some(ping) = config.account.ping {
let ping = tokio::timer::Interval::new_interval(std::time::Duration::from_secs(ping));
rt.spawn(
ping.map_err(|e| {
error!("Ping error: {}", e);
})
.for_each(move |_| {
cmd_send
.clone()
.send(XmppCommand::Ping)
.map_err(|e| {
error!("Ping command error: {}", e);
})
.map(|_| ())
})
.select(
ctrl_c
.clone()
.map(|_| ())
.map_err(|e| error!("ping server error: {}", e)),
)
.map(|_| ())
.map_err(|_| ()),
);
}
replacement in src/main.rs at line 267

[3.50840]→[2.46249:46330](∅→∅)

let xmpp_join = std::thread::spawn(move || -> Result<(), tokio::io::Error> {

[3.50840]

[3.50919]

let xmpp_join = std::thread::spawn(move || -> Result<(), failure::Error> {
replacement in src/main.rs at line 271

[3.51089]→[2.46331:46478](∅→∅)

let result = ctrt.block_on(xmpp_process(
ctrl_c.clone().map(|_| ()),
recv,
config.account,
));

[3.51089]

[3.51177]

let result = ctrt.block_on(xmpp_process(ctrl_c.clone(), recv, config.account));
edit in src/config.rs at line 0

[3.1396]

[3.1397]

use std::collections::HashMap;
replacement in src/config.rs at line 7

[3.1502]→[2.46479:46500](∅→∅)

pub jid: String,

[3.1502]

[3.1523]

#[serde(deserialize_with = "deserialize_jid")]
pub jid: xmpp_parsers::Jid,
edit in src/config.rs at line 10

[3.1549]

[3.1549]

#[serde(default, deserialize_with = "deserialize_jid_map")]
pub chatrooms: HashMap<String, xmpp_parsers::Jid>,
pub ping: Option<u64>,
replacement in src/config.rs at line 22

[3.1681]→[2.46501:46565](∅→∅)

pub fn new<P: AsRef<Path>>(path: P) -> io::Result<Config> {

[3.1681]

[3.1745]

pub fn read<P: AsRef<Path>>(path: P) -> io::Result<Self> {
edit in src/config.rs at line 30

[3.1943]

[3.1943]

}

fn deserialize_jid<'de, D>(deserializer: D) -> Result<xmpp_parsers::Jid, D::Error>
where
D: serde::Deserializer<'de>,
{
use serde::Deserialize;
let s = String::deserialize(deserializer)?;
std::str::FromStr::from_str(&s).map_err(serde::de::Error::custom)
}

fn deserialize_jid_map<'de, D>(
deserializer: D,
) -> Result<HashMap<String, xmpp_parsers::Jid>, D::Error>
where
D: serde::Deserializer<'de>,
{
use serde::Deserialize;
let s = HashMap::<String, String>::deserialize(deserializer)?;

let size = s.len();
s.into_iter()
.map(|(k, v)| (k, std::str::FromStr::from_str(&v)))
.take_while(|(_k, r)| r.is_ok())
.fold(Ok(HashMap::with_capacity(size)), |res, (k, r)| match res {
Ok(mut res) => match r {
Ok(v) => {
res.insert(k, v);
Ok(res)
}
Err(e) => Err(e),
},
Err(e) => Err(e),
})
.map_err(serde::de::Error::custom)
edit in README.md at line 0

[3.76]

### XMPP client daemon

#### Sending messages

```
curl http://localhost:8083/ -H "X-XMPP-To: some@domain.org" -d "Test"
```

#### Sending messages to MUC

```
curl http://localhost:8083/ -H "X-XMPP-Muc: smac" -d "Test"
```
edit in Cargo.toml at line 6

[3.12171]

[3.12171]

edition = "2018"
replacement in Cargo.toml at line 12

[3.52696]→[2.46566:46585](∅→∅)

tokio-xmpp = "0.2"

[3.52696]

[3.52735]

tokio-xmpp = "1.0.0"
failure = "0.1.5"
replacement in Cargo.toml at line 15

[3.52750]→[2.46586:46599](∅→∅)

toml = "0.4"

[3.52750]

[3.52763]

toml = "0.5"
replacement in Cargo.toml at line 20

[3.52824]→[2.46600:46661](∅→∅)

env_logger = "0.5"
minidom = "=0.9.1"
xmpp-parsers = "0.11"

[3.52824]

env_logger = "0.6"
xmpp-parsers = "0.13"
minidom = "=0.10.0" # xmpp-parsers
lazy_static = "1.3.0" # ToDo: remove after const fn will be powerfull enough
edit in Cargo.lock at line 0

[3.12201]

[3.53201]

# This file is automatically @generated by Cargo.
# It is not intended for manual editing.
[[package]]
name = "MacTypes-sys"
version = "2.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
]
replacement in Cargo.lock at line 12

[3.53235]→[2.46662:46680](∅→∅)

version = "0.6.8"

[3.53235]

[3.53253]

version = "0.7.3"
replacement in Cargo.lock at line 15

[3.53335]→[2.46681:46754](∅→∅)

"memchr 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)",

[3.53335]

[3.53408]

"memchr 2.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 23

[3.53543]→[2.46755:46828](∅→∅)

"winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",

[3.53543]

[3.53616]

"winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 28

[3.53649]→[2.46829:46847](∅→∅)

version = "0.3.4"

[3.53649]

[2.46847]

version = "0.3.10"
edit in Cargo.lock at line 32

[2.46925]→[2.46925:46961](∅→∅),[2.46961]→[3.53668:53746](∅→∅),[3.34547]→[3.53668:53746](∅→∅),[3.53668]→[3.53668:53746](∅→∅)

name = "arrayref"
version = "0.3.5"
source = "registry+https://github.com/rust-lang/crates.io-index"

[[package]]
replacement in Cargo.lock at line 33

[3.53764]→[2.46962:46980](∅→∅)

version = "0.4.7"

[3.53764]

[3.53783]

version = "0.4.10"
replacement in Cargo.lock at line 36

[3.53865]→[2.46981:47055](∅→∅)

"nodrop 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",

[3.53865]

[3.53939]

"nodrop 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 44

[3.54069]→[2.47056:47128](∅→∅)

"libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",

[3.54069]

[3.54141]

"libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 46

[3.54215]→[2.47129:47202](∅→∅)

"winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",

[3.54215]

[3.54288]

"winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 50

[3.54303]→[2.47203:47240](∅→∅)

name = "backtrace"
version = "0.2.3"

[3.54303]

[3.54338]

name = "autocfg"
version = "0.1.2"
edit in Cargo.lock at line 53

[3.54403]→[2.47241:47797](∅→∅)

dependencies = [
"backtrace-sys 0.1.24 (registry+https://github.com/rust-lang/crates.io-index)",
"cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
"dbghelp-sys 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
"kernel32-sys 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
"libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
"rustc-demangle 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
"winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
]
replacement in Cargo.lock at line 56

[3.54435]→[2.47798:47816](∅→∅)

version = "0.3.9"

[3.54435]

[3.54454]

version = "0.3.15"
replacement in Cargo.lock at line 59

[3.54536]→[2.47817:48197](∅→∅)

"backtrace-sys 0.1.24 (registry+https://github.com/rust-lang/crates.io-index)",
"cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
"libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
"rustc-demangle 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
"winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",

[3.54536]

[3.54991]

"autocfg 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
"backtrace-sys 0.1.28 (registry+https://github.com/rust-lang/crates.io-index)",
"cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
"libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
"rustc-demangle 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)",
"winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 69

[3.55029]→[2.48198:48217](∅→∅)

version = "0.1.24"

[3.55029]

[3.55048]

version = "0.1.28"
replacement in Cargo.lock at line 72

[3.55130]→[2.48218:48360](∅→∅)

"cc 1.0.25 (registry+https://github.com/rust-lang/crates.io-index)",
"libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",

[3.55130]

[3.55272]

"cc 1.0.35 (registry+https://github.com/rust-lang/crates.io-index)",
"libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 78

[3.55303]→[2.48361:48379](∅→∅)

version = "0.9.3"

[3.55303]

[3.55322]

version = "0.10.1"
replacement in Cargo.lock at line 81

[3.55404]→[2.48380:48530](∅→∅)

"byteorder 1.2.7 (registry+https://github.com/rust-lang/crates.io-index)",
"safemem 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",

[3.55404]

[3.55480]

"byteorder 1.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 91

[3.55625]→[2.48531:48549](∅→∅)

version = "0.7.1"

[3.55625]

[3.55643]

version = "0.8.0"
replacement in Cargo.lock at line 94

[3.55725]→[2.48550:48777](∅→∅)

"byte-tools 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
"crypto-mac 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)",
"digest 0.7.6 (registry+https://github.com/rust-lang/crates.io-index)",

[3.55725]

[3.56031]

"byte-tools 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
"crypto-mac 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
"digest 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
"opaque-debug 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 102

[3.56068]→[2.48778:48796](∅→∅)

version = "0.3.3"

[3.56068]

[3.56538]

version = "0.7.0"
replacement in Cargo.lock at line 105

[3.56620]→[2.48797:48949](∅→∅)

"arrayref 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
"byte-tools 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",

[3.56620]

[3.56697]

"block-padding 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
"byte-tools 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
"byteorder 1.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
"generic-array 0.12.0 (registry+https://github.com/rust-lang/crates.io-index)",
]

[[package]]
name = "block-padding"
version = "0.1.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"byte-tools 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 121

[3.56732]→[2.48950:48968](∅→∅)

version = "0.2.0"

[3.56732]

[3.56750]

version = "0.3.1"
replacement in Cargo.lock at line 126

[3.56847]→[2.48969:48987](∅→∅)

version = "1.2.7"

[3.56847]

[3.56865]

version = "1.3.1"
replacement in Cargo.lock at line 131

[3.56958]→[2.48988:49007](∅→∅)

version = "0.4.10"

[3.56958]

[3.56977]

version = "0.4.12"
replacement in Cargo.lock at line 134

[3.57059]→[2.49008:49084](∅→∅)

"byteorder 1.2.7 (registry+https://github.com/rust-lang/crates.io-index)",

[3.57059]

[3.57135]

"byteorder 1.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 145

[3.57344]→[2.49085:49104](∅→∅)

version = "1.0.25"

[3.57344]

[3.57363]

version = "1.0.35"
replacement in Cargo.lock at line 150

[3.57457]→[2.49105:49123](∅→∅)

version = "0.1.6"

[3.57457]

[3.57475]

version = "0.1.7"
replacement in Cargo.lock at line 160

[3.57825]→[2.49124:49196](∅→∅)

"time 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)",

[3.57825]

[3.57897]

"time 0.1.42 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 165

[3.57926]→[2.49197:49216](∅→∅)

version = "2.32.0"

[3.57926]

[3.57945]

version = "2.33.0"
replacement in Cargo.lock at line 171

[3.58251]→[2.49217:49366](∅→∅)

"strsim 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
"textwrap 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)",

[3.58251]

[3.58400]

"strsim 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
"textwrap 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)",
edit in Cargo.lock at line 186

[3.58777]→[2.49367:49489](∅→∅)

name = "constant_time_eq"
version = "0.1.3"
source = "registry+https://github.com/rust-lang/crates.io-index"

[[package]]
replacement in Cargo.lock at line 191

[3.58988]→[2.49490:49562](∅→∅)

"libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",

[3.58988]

[3.59060]

"libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 199

[3.59204]→[2.49563:49635](∅→∅)

"libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",

[3.59204]

[3.59276]

"libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 204

[3.59316]→[2.49636:49654](∅→∅)

version = "0.6.1"

[3.59316]

[3.59334]

version = "0.7.1"
replacement in Cargo.lock at line 207

[3.59416]→[2.49655:49819](∅→∅)

"crossbeam-epoch 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)",
"crossbeam-utils 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)",

[3.59416]

[3.59580]

"crossbeam-epoch 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)",
"crossbeam-utils 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 213

[3.59620]→[2.49820:49838](∅→∅)

version = "0.5.2"

[3.59620]

[3.59638]

version = "0.7.1"
replacement in Cargo.lock at line 216

[3.59720]→[2.49839:50147](∅→∅)

"arrayvec 0.4.7 (registry+https://github.com/rust-lang/crates.io-index)",
"cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
"crossbeam-utils 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)",
"lazy_static 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",

[3.59720]

[3.60029]

"arrayvec 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)",
"cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
"crossbeam-utils 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)",
"lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 225

[3.60197]→[2.50148:50191](∅→∅)

name = "crossbeam-utils"
version = "0.5.0"

[3.60197]

[3.60240]

name = "crossbeam-queue"
version = "0.1.2"
edit in Cargo.lock at line 228

[3.60305]

[3.60406]

dependencies = [
"crossbeam-utils 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)",
]
replacement in Cargo.lock at line 233

[3.60419]→[2.50192:50230](∅→∅)

name = "crypto-mac"
version = "0.5.2"

[3.60419]

[3.60462]

name = "crossbeam-utils"
version = "0.6.5"
replacement in Cargo.lock at line 237

[3.60544]→[2.50231:50394](∅→∅)

"constant_time_eq 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
"generic-array 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)",

[3.60544]

[3.60695]

"cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
"lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 242

[3.60710]→[2.50395:50434](∅→∅)

name = "dbghelp-sys"
version = "0.2.0"

[3.60710]

[3.60748]

name = "crypto-mac"
version = "0.7.0"
replacement in Cargo.lock at line 246

[3.60830]→[2.50435:50587](∅→∅)

"winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
"winapi-build 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",

[3.60830]

[3.60984]

"generic-array 0.12.0 (registry+https://github.com/rust-lang/crates.io-index)",
"subtle 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 262

[3.61368]→[2.50588:50606](∅→∅)

version = "0.7.6"

[3.61368]

[3.61386]

version = "0.8.0"
replacement in Cargo.lock at line 265

[3.61468]→[2.50607:50687](∅→∅)

"generic-array 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)",

[3.61468]

[3.61549]

"generic-array 0.12.0 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 270

[3.61585]→[2.50688:50707](∅→∅)

version = "0.8.10"

[3.61585]

[3.61604]

version = "0.8.17"
replacement in Cargo.lock at line 273

[3.61686]→[2.50708:50781](∅→∅)

"cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",

[3.61686]

[3.61759]

"cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 278

[3.61794]→[2.50782:50801](∅→∅)

version = "0.5.13"

[3.61794]

[3.61812]

version = "0.6.1"
replacement in Cargo.lock at line 282

[3.61966]→[2.50802:51020](∅→∅)

"humantime 1.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
"log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
"regex 1.0.5 (registry+https://github.com/rust-lang/crates.io-index)",

[3.61966]

[3.62184]

"humantime 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
"log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
"regex 1.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
edit in Cargo.lock at line 286

[3.62260]→[2.51021:51234](∅→∅)

]

[[package]]
name = "error-chain"
version = "0.1.12"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"backtrace 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 293

[3.62396]→[2.51235:51311](∅→∅)

"backtrace 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",

[3.62396]

[3.62473]

"backtrace 0.3.15 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 298

[3.62505]→[2.51312:51330](∅→∅)

version = "0.1.3"

[3.62505]

[3.62523]

version = "0.1.5"
replacement in Cargo.lock at line 301

[3.62605]→[2.51331:51488](∅→∅)

"backtrace 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
"failure_derive 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",

[3.62605]

[3.62763]

"backtrace 0.3.15 (registry+https://github.com/rust-lang/crates.io-index)",
"failure_derive 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 307

[3.62802]→[2.51489:51507](∅→∅)

version = "0.1.3"

[3.62802]

[3.62820]

version = "0.1.5"
replacement in Cargo.lock at line 310

[3.62902]→[2.51508:51811](∅→∅)

"proc-macro2 0.4.20 (registry+https://github.com/rust-lang/crates.io-index)",
"quote 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)",
"syn 0.15.14 (registry+https://github.com/rust-lang/crates.io-index)",
"synstructure 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)",

[3.62902]

[3.63206]

"proc-macro2 0.4.27 (registry+https://github.com/rust-lang/crates.io-index)",
"quote 0.6.12 (registry+https://github.com/rust-lang/crates.io-index)",
"syn 0.15.30 (registry+https://github.com/rust-lang/crates.io-index)",
"synstructure 0.10.1 (registry+https://github.com/rust-lang/crates.io-index)",
edit in Cargo.lock at line 340

[3.63796]

[3.63915]

name = "fuchsia-cprng"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"

[[package]]
replacement in Cargo.lock at line 364

[3.64522]→[2.51812:51900](∅→∅)

"new_debug_unreachable 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",

[3.64522]

[3.64610]

"new_debug_unreachable 1.0.3 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 369

[3.64642]→[2.51901:51920](∅→∅)

version = "0.1.25"

[3.64642]

[3.64661]

version = "0.1.26"
replacement in Cargo.lock at line 377

[3.64864]→[2.51921:52071](∅→∅)

"futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
"num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)",

[3.64864]

[3.65015]

"futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
"num_cpus 1.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 383

[3.65053]→[2.52072:52090](∅→∅)

version = "0.9.0"

[3.65053]

[3.65072]

version = "0.12.0"
replacement in Cargo.lock at line 391

[3.65256]→[2.52091:52110](∅→∅)

version = "0.1.13"

[3.65256]

[3.65275]

version = "0.1.18"
replacement in Cargo.lock at line 394

[3.65357]→[2.52111:52260](∅→∅)

"byteorder 1.2.7 (registry+https://github.com/rust-lang/crates.io-index)",
"bytes 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)",

[3.65357]

[3.65506]

"byteorder 1.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
"bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 397

[3.65576]→[2.52261:52408](∅→∅)

"futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
"http 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",

[3.65576]

[3.65723]

"futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
"http 0.1.17 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 400

[3.65798]→[2.52409:52699](∅→∅)

"log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
"slab 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
"string 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",

[3.65798]

[3.66088]

"log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
"slab 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
"string 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-io 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
]

[[package]]
name = "hmac"
version = "0.7.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"crypto-mac 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
"digest 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 420

[3.66500]→[2.52700:52772](∅→∅)

"libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",

[3.66500]

[3.66572]

"libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 426

[3.66675]→[2.52773:52792](∅→∅)

version = "0.1.13"

[3.66675]

[3.66694]

version = "0.1.17"
replacement in Cargo.lock at line 429

[3.66776]→[2.52793:52866](∅→∅)

"bytes 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)",

[3.66776]

[3.66849]

"bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 441

[3.67138]→[2.52867:52885](∅→∅)

version = "1.1.1"

[3.67138]

[3.67156]

version = "1.2.0"
replacement in Cargo.lock at line 449

[3.67346]→[2.52886:52906](∅→∅)

version = "0.12.13"

[3.67346]

[3.67366]

version = "0.12.27"
replacement in Cargo.lock at line 452

[3.67448]→[2.52907:53055](∅→∅)

"bytes 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)",
"futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",

[3.67448]

[3.67596]

"bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
"futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 455

[3.67678]→[2.53056:53198](∅→∅)

"h2 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
"http 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",

[3.67678]

[3.67820]

"h2 0.1.18 (registry+https://github.com/rust-lang/crates.io-index)",
"http 0.1.17 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 460

[3.68038]→[2.53199:53269](∅→∅)

"log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",

[3.68038]

[3.68108]

"log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 462

[3.68180]→[2.53270:53889](∅→∅)

"time 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-executor 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-reactor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-tcp 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-threadpool 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-timer 0.2.7 (registry+https://github.com/rust-lang/crates.io-index)",

[3.68180]

[3.68881]

"rustc_version 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
"time 0.1.42 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio 0.1.18 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-executor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-io 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-reactor 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-tcp 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-threadpool 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-timer 0.2.10 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 481

[3.69234]→[2.53890:53978](∅→∅)

"unicode-normalization 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",

[3.69234]

[3.69322]

"unicode-normalization 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 494

[3.69566]→[2.53979:54051](∅→∅)

"libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",

[3.69566]

[3.69638]

"libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 500

[3.69744]→[2.54052:54070](∅→∅)

version = "0.1.7"

[3.69744]

[3.69762]

version = "0.1.9"
replacement in Cargo.lock at line 506

[3.70073]→[2.54071:54144](∅→∅)

"winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",

[3.70073]

[3.70146]

"winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 517

[3.70357]→[2.54145:54163](∅→∅)

version = "0.5.2"

[3.70357]

[3.70375]

version = "0.5.3"
replacement in Cargo.lock at line 520

[3.70457]→[2.54164:54393](∅→∅)

"failure 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
"failure_derive 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
"minidom 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)",

[3.70457]

[3.70687]

"failure 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
"failure_derive 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
"minidom 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 541

[3.71124]→[2.54394:54412](∅→∅)

version = "1.1.0"

[3.71124]

[3.71142]

version = "1.3.0"
edit in Cargo.lock at line 543

[3.71207]→[2.54413:54512](∅→∅)

dependencies = [
"version_check 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
]
replacement in Cargo.lock at line 546

[3.71238]→[2.54513:54531](∅→∅)

version = "1.2.0"

[3.71238]

[3.71256]

version = "1.2.1"
replacement in Cargo.lock at line 551

[3.71348]→[2.54532:54551](∅→∅)

version = "0.2.43"

[3.71348]

[3.71367]

version = "0.2.51"
replacement in Cargo.lock at line 556

[3.71470]→[2.54552:54570](∅→∅)

version = "0.4.2"

[3.71470]

[3.71488]

version = "0.5.2"
replacement in Cargo.lock at line 561

[3.71584]→[2.54571:54589](∅→∅)

version = "0.1.4"

[3.71584]

[3.71602]

version = "0.1.5"
replacement in Cargo.lock at line 564

[3.71684]→[2.54590:54667](∅→∅)

"owning_ref 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",

[3.71684]

[3.71761]

"owning_ref 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
edit in Cargo.lock at line 566

[3.71838]→[3.71838:71866](∅→∅),[3.71838]→[3.71838:71866](∅→∅),[3.71866]→[2.54668:54686](∅→∅),[2.54686]→[3.71884:71966](∅→∅),[3.71884]→[3.71884:71966](∅→∅),[3.71966]→[2.54687:54757](∅→∅)

]

[[package]]
name = "log"
version = "0.3.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 570

[2.54785]→[2.54785:54803](∅→∅)

version = "0.4.5"

[2.54785]

[2.54803]

version = "0.4.6"
replacement in Cargo.lock at line 573

[2.54885]→[2.54885:54958](∅→∅)

"cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",

[2.54885]

[3.72039]

"cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 578

[3.72073]→[2.54959:54977](∅→∅)

version = "0.1.1"

[3.72073]

[3.72091]

version = "0.1.2"
replacement in Cargo.lock at line 581

[3.72173]→[2.54978:55060](∅→∅)

"linked-hash-map 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",

[3.72173]

[3.72255]

"linked-hash-map 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 591

[3.72400]→[2.55061:55079](∅→∅)

version = "0.7.3"

[3.72400]

[3.72418]

version = "0.7.5"
replacement in Cargo.lock at line 594

[3.72500]→[2.55080:55461](∅→∅)

"phf 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",
"phf_codegen 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",
"serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
"serde_derive 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
"serde_json 1.0.32 (registry+https://github.com/rust-lang/crates.io-index)",

[3.72500]

[3.72881]

"phf 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)",
"phf_codegen 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)",
"serde 1.0.90 (registry+https://github.com/rust-lang/crates.io-index)",
"serde_derive 1.0.90 (registry+https://github.com/rust-lang/crates.io-index)",
"serde_json 1.0.39 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 601

[3.73047]→[2.55462:55536](∅→∅)

"tendril 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",

[3.73047]

[3.73121]

"tendril 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 611

[3.73265]→[2.55537:55555](∅→∅)

version = "2.1.0"

[3.73265]

[3.73283]

version = "2.2.0"
edit in Cargo.lock at line 613

[3.73348]→[2.55556:55800](∅→∅)

dependencies = [
"cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
"libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
"version_check 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
]
replacement in Cargo.lock at line 621

[3.73493]→[2.55801:55819](∅→∅)

version = "0.9.1"

[3.73493]

[3.73512]

version = "0.10.0"
replacement in Cargo.lock at line 624

[3.73594]→[2.55820:56052](∅→∅)

"failure 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
"failure_derive 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
"quick-xml 0.12.4 (registry+https://github.com/rust-lang/crates.io-index)",

[3.73594]

[3.73826]

"failure 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
"failure_derive 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
"quick-xml 0.13.3 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 638

[3.74272]→[2.56053:56270](∅→∅)

"lazycell 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
"libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
"log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",

[3.74272]

[3.74489]

"lazycell 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
"libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
"log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 643

[3.74632]→[2.56271:56342](∅→∅)

"slab 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",

[3.74632]

[3.74703]

"slab 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 653

[3.74980]→[2.56343:56415](∅→∅)

"libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",

[3.74980]

[3.75052]

"libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 673

[3.75688]→[2.56416:56712](∅→∅)

"lazy_static 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
"libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
"log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
"openssl 0.10.15 (registry+https://github.com/rust-lang/crates.io-index)",

[3.75688]

[3.75984]

"lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
"libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
"log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
"openssl 0.10.20 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 678

[3.76064]→[2.56713:57117](∅→∅)

"openssl-sys 0.9.39 (registry+https://github.com/rust-lang/crates.io-index)",
"schannel 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)",
"security-framework 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
"security-framework-sys 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
"tempfile 3.0.4 (registry+https://github.com/rust-lang/crates.io-index)",

[3.76064]

[3.76468]

"openssl-sys 0.9.43 (registry+https://github.com/rust-lang/crates.io-index)",
"schannel 0.1.15 (registry+https://github.com/rust-lang/crates.io-index)",
"security-framework 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
"security-framework-sys 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
"tempfile 3.0.7 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 690

[3.76598]→[2.57118:57336](∅→∅)

"cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
"libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
"winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",

[3.76598]

[3.76816]

"cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
"libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
"winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 697

[3.76862]→[2.57337:57355](∅→∅)

version = "1.0.1"

[3.76862]

[3.76880]

version = "1.0.3"
edit in Cargo.lock at line 699

[3.76945]→[2.57356:57453](∅→∅)

dependencies = [
"unreachable 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
replacement in Cargo.lock at line 702

[3.76974]→[2.57454:57473](∅→∅)

version = "0.1.12"

[3.76974]

[3.76993]

version = "0.1.13"
replacement in Cargo.lock at line 720

[3.77419]→[2.57474:57492](∅→∅)

version = "1.8.0"

[3.77419]

[3.77438]

version = "1.10.0"
replacement in Cargo.lock at line 723

[3.77520]→[2.57493:57565](∅→∅)

"libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",

[3.77520]

[3.77592]

"libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
edit in Cargo.lock at line 725

[3.77594]

[3.77712]

[[package]]
name = "opaque-debug"
version = "0.2.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
replacement in Cargo.lock at line 733

[3.77742]→[2.57566:57586](∅→∅)

version = "0.10.15"

[3.77742]

[3.77762]

version = "0.10.20"
replacement in Cargo.lock at line 737

[3.77919]→[2.57587:57660](∅→∅)

"cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",

[3.77919]

[3.77992]

"cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 739

[3.78072]→[2.57661:57890](∅→∅)

"lazy_static 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
"libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
"openssl-sys 0.9.39 (registry+https://github.com/rust-lang/crates.io-index)",

[3.78072]

[3.78301]

"lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
"libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
"openssl-sys 0.9.43 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 751

[3.78456]→[2.57891:57910](∅→∅)

version = "0.9.39"

[3.78456]

[3.78475]

version = "0.9.43"
replacement in Cargo.lock at line 754

[3.78557]→[2.57911:58053](∅→∅)

"cc 1.0.25 (registry+https://github.com/rust-lang/crates.io-index)",
"libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",

[3.78557]

[3.78699]

"cc 1.0.35 (registry+https://github.com/rust-lang/crates.io-index)",
"libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
edit in Cargo.lock at line 757

[3.78777]

[3.78857]

"rustc_version 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 763

[3.78964]→[2.58054:58072](∅→∅)

version = "0.3.3"

[3.78964]

[3.78982]

version = "0.4.0"
replacement in Cargo.lock at line 771

[3.79185]→[2.58073:58091](∅→∅)

version = "0.6.4"

[3.79185]

[3.79203]

version = "0.7.1"
replacement in Cargo.lock at line 774

[3.79285]→[2.58092:58250](∅→∅)

"lock_api 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
"parking_lot_core 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",

[3.79285]

[3.79443]

"lock_api 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
"parking_lot_core 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 780

[3.79484]→[2.58251:58269](∅→∅)

version = "0.3.1"

[3.79484]

[3.79502]

version = "0.4.0"
replacement in Cargo.lock at line 783

[3.79584]→[2.58270:58413](∅→∅)

"libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
"rand 0.5.5 (registry+https://github.com/rust-lang/crates.io-index)",

[3.79584]

[3.79727]

"libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
"rand 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 786

[3.79807]→[2.58414:58562](∅→∅)

"smallvec 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)",
"winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",

[3.79807]

[3.80239]

"smallvec 0.6.9 (registry+https://github.com/rust-lang/crates.io-index)",
"winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
]

[[package]]
name = "pbkdf2"
version = "0.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"byteorder 1.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
"crypto-mac 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 806

[3.80389]→[2.58563:58582](∅→∅)

version = "0.7.23"

[3.80389]

[3.80408]

version = "0.7.24"
replacement in Cargo.lock at line 809

[3.80490]→[2.58583:58661](∅→∅)

"phf_shared 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",

[3.80490]

[3.80568]

"phf_shared 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 814

[3.80604]→[2.58662:58681](∅→∅)

version = "0.7.23"

[3.80604]

[3.80623]

version = "0.7.24"
replacement in Cargo.lock at line 817

[3.80705]→[2.58682:58841](∅→∅)

"phf_generator 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",
"phf_shared 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",

[3.80705]

[3.80864]

"phf_generator 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)",
"phf_shared 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 823

[3.80902]→[2.58842:58861](∅→∅)

version = "0.7.23"

[3.80902]

[3.80921]

version = "0.7.24"
replacement in Cargo.lock at line 826

[3.81003]→[2.58862:59011](∅→∅)

"phf_shared 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",
"rand 0.5.5 (registry+https://github.com/rust-lang/crates.io-index)",

[3.81003]

[3.81152]

"phf_shared 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)",
"rand 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 832

[3.81187]→[2.59012:59031](∅→∅)

version = "0.7.23"

[3.81187]

[3.81206]

version = "0.7.24"
replacement in Cargo.lock at line 850

[3.81639]→[2.59032:59051](∅→∅)

version = "0.4.20"

[3.81639]

[3.81658]

version = "0.4.27"
replacement in Cargo.lock at line 863

[3.81969]→[2.59052:59071](∅→∅)

version = "0.12.4"

[3.81969]

[3.81988]

version = "0.13.3"
replacement in Cargo.lock at line 866

[3.82070]→[2.59072:59368](∅→∅)

"encoding_rs 0.8.10 (registry+https://github.com/rust-lang/crates.io-index)",
"failure 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
"log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
"memchr 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)",

[3.82070]

[3.82366]

"encoding_rs 0.8.17 (registry+https://github.com/rust-lang/crates.io-index)",
"failure 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
"log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
"memchr 2.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 879

[3.82508]→[2.59369:59387](∅→∅)

version = "0.6.8"

[3.82508]

[3.82527]

version = "0.6.12"
replacement in Cargo.lock at line 882

[3.82609]→[2.59388:59467](∅→∅)

"proc-macro2 0.4.20 (registry+https://github.com/rust-lang/crates.io-index)",

[3.82609]

[3.82688]

"proc-macro2 0.4.27 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 887

[3.82717]→[2.59468:59486](∅→∅)

version = "0.4.3"

[3.82717]

[3.82735]

version = "0.5.6"
replacement in Cargo.lock at line 890

[3.82817]→[2.59487:59713](∅→∅)

"fuchsia-zircon 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
"libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
"winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",

[3.82817]

[3.83193]

"cloudabi 0.0.3 (registry+https://github.com/rust-lang/crates.io-index)",
"fuchsia-cprng 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
"libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
"rand_core 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
"winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 899

[3.83222]→[2.59714:59732](∅→∅)

version = "0.5.5"

[3.83222]

[3.83240]

version = "0.6.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"autocfg 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
"libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
"rand_chacha 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
"rand_core 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
"rand_hc 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
"rand_isaac 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
"rand_jitter 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
"rand_os 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
"rand_pcg 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
"rand_xorshift 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
"winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
]

[[package]]
name = "rand_chacha"
version = "0.1.1"
replacement in Cargo.lock at line 920

[3.83322]→[2.59733:60110](∅→∅)

"cloudabi 0.0.3 (registry+https://github.com/rust-lang/crates.io-index)",
"fuchsia-zircon 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
"libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
"rand_core 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
"winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",

[3.83322]

[3.84153]

"autocfg 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
"rand_core 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 926

[3.84473]→[2.60111:60129](∅→∅)

version = "0.2.2"

[3.84473]

[3.84491]

version = "0.3.1"
replacement in Cargo.lock at line 929

[3.84573]→[2.60130:60206](∅→∅)

"rand_core 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",

[3.84573]

[3.84649]

"rand_core 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 934

[3.84683]→[2.60207:60225](∅→∅)

version = "0.3.0"

[3.84683]

[3.86667]

version = "0.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"

[[package]]
name = "rand_hc"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"rand_core 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
]

[[package]]
name = "rand_isaac"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"rand_core 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
]

[[package]]
name = "rand_jitter"
version = "0.1.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
"rand_core 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
"winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
]

[[package]]
name = "rand_os"
version = "0.1.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"cloudabi 0.0.3 (registry+https://github.com/rust-lang/crates.io-index)",
"fuchsia-cprng 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
"libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
"rand_core 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
"rdrand 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
"winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
]

[[package]]
name = "rand_pcg"
version = "0.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"autocfg 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
"rand_core 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
]

[[package]]
name = "rand_xorshift"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"rand_core 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
]

[[package]]
name = "rdrand"
version = "0.4.0"
edit in Cargo.lock at line 997

[3.86732]

[3.86827]

dependencies = [
"rand_core 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
]
replacement in Cargo.lock at line 1003

[3.86863]→[2.60226:60245](∅→∅)

version = "0.1.40"

[3.86863]

[3.86882]

version = "0.1.54"
replacement in Cargo.lock at line 1011

[3.87083]→[2.60246:60327](∅→∅)

"redox_syscall 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)",

[3.87083]

[3.87164]

"redox_syscall 0.1.54 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1016

[3.87194]→[2.60328:60346](∅→∅)

version = "1.0.5"

[3.87194]

[3.87212]

version = "1.1.5"
replacement in Cargo.lock at line 1019

[3.87294]→[2.60347:60578](∅→∅)

"aho-corasick 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)",
"memchr 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
"regex-syntax 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)",

[3.87294]

[3.87525]

"aho-corasick 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)",
"memchr 2.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
"regex-syntax 0.6.6 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1023

[3.87604]→[2.60579:60657](∅→∅)

"utf8-ranges 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",

[3.87604]

[3.87682]

"utf8-ranges 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1028

[3.87719]→[2.60658:60676](∅→∅)

version = "0.6.2"

[3.87719]

[3.87737]

version = "0.6.6"
replacement in Cargo.lock at line 1031

[3.87819]→[2.60677:60752](∅→∅)

"ucd-util 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",

[3.87819]

[3.87894]

"ucd-util 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1039

[3.88033]→[2.60753:60826](∅→∅)

"winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",

[3.88033]

[3.88106]

"winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1044

[3.88142]→[2.60827:60845](∅→∅)

version = "0.6.1"

[3.88142]

[3.88160]

version = "0.6.2"
replacement in Cargo.lock at line 1053

[3.88434]→[2.60846:60864](∅→∅)

version = "0.1.9"

[3.88434]

[3.88453]

version = "0.1.14"
replacement in Cargo.lock at line 1066

[3.88755]→[2.60865:60996](∅→∅)

version = "0.2.6"
source = "registry+https://github.com/rust-lang/crates.io-index"

[[package]]
name = "safemem"
version = "0.3.0"

[3.88755]

[3.88773]

version = "0.2.7"
replacement in Cargo.lock at line 1071

[3.88865]→[2.60997:61015](∅→∅)

version = "0.4.2"

[3.88865]

[3.88883]

version = "0.4.3"
replacement in Cargo.lock at line 1074

[3.88965]→[2.61016:61165](∅→∅)

"base64 0.9.3 (registry+https://github.com/rust-lang/crates.io-index)",
"openssl 0.10.15 (registry+https://github.com/rust-lang/crates.io-index)",

[3.88965]

[3.89400]

"base64 0.10.1 (registry+https://github.com/rust-lang/crates.io-index)",
"hmac 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
"pbkdf2 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
"rand_os 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
"sha-1 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)",
"sha2 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1084

[3.89433]→[2.61166:61185](∅→∅)

version = "0.1.14"

[3.89433]

[3.89452]

version = "0.1.15"
replacement in Cargo.lock at line 1087

[3.89534]→[2.61186:61337](∅→∅)

"lazy_static 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
"winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",

[3.89534]

[3.89685]

"lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
"winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1098

[3.89844]→[2.61338:61356](∅→∅)

version = "0.2.1"

[3.89844]

[3.89862]

version = "0.2.2"
replacement in Cargo.lock at line 1103

[3.90112]→[2.61357:61518](∅→∅)

"libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
"security-framework-sys 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",

[3.90112]

[3.90273]

"libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
"security-framework-sys 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1109

[3.90320]→[2.61519:61537](∅→∅)

version = "0.2.1"

[3.90320]

[3.90338]

version = "0.2.3"
edit in Cargo.lock at line 1112

[3.90420]

[3.90499]

"MacTypes-sys 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1114

[3.90585]→[2.61538:61610](∅→∅)

"libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",

[3.90585]

[3.90657]

"libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1134

[3.91027]→[2.61611:62205](∅→∅)

"clap 2.32.0 (registry+https://github.com/rust-lang/crates.io-index)",
"env_logger 0.5.13 (registry+https://github.com/rust-lang/crates.io-index)",
"hyper 0.12.13 (registry+https://github.com/rust-lang/crates.io-index)",
"log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
"minidom 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)",
"serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
"serde_derive 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",

[3.91027]

[3.91695]

"clap 2.33.0 (registry+https://github.com/rust-lang/crates.io-index)",
"env_logger 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
"failure 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
"hyper 0.12.27 (registry+https://github.com/rust-lang/crates.io-index)",
"lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
"log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
"minidom 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
"serde 1.0.90 (registry+https://github.com/rust-lang/crates.io-index)",
"serde_derive 1.0.90 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio 0.1.18 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1145

[3.91775]→[2.62206:62513](∅→∅)

"tokio-signal 0.2.6 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-xmpp 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
"toml 0.4.8 (registry+https://github.com/rust-lang/crates.io-index)",
"xmpp-parsers 0.11.1 (registry+https://github.com/rust-lang/crates.io-index)",

[3.91775]

[3.92082]

"tokio-signal 0.2.7 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-xmpp 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
"toml 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)",
"xmpp-parsers 0.13.1 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1153

[3.92112]→[2.62514:62533](∅→∅)

version = "1.0.80"

[3.92112]

[3.92131]

version = "1.0.90"
replacement in Cargo.lock at line 1158

[3.92231]→[2.62534:62553](∅→∅)

version = "1.0.80"

[3.92231]

[3.92250]

version = "1.0.90"
replacement in Cargo.lock at line 1161

[3.92332]→[2.62554:62777](∅→∅)

"proc-macro2 0.4.20 (registry+https://github.com/rust-lang/crates.io-index)",
"quote 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)",
"syn 0.15.14 (registry+https://github.com/rust-lang/crates.io-index)",

[3.92332]

[3.92556]

"proc-macro2 0.4.27 (registry+https://github.com/rust-lang/crates.io-index)",
"quote 0.6.12 (registry+https://github.com/rust-lang/crates.io-index)",
"syn 0.15.30 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1168

[3.92591]→[2.62778:62797](∅→∅)

version = "1.0.32"

[3.92591]

[3.92610]

version = "1.0.39"
replacement in Cargo.lock at line 1172

[3.92763]→[2.62798:62941](∅→∅)

"ryu 0.2.6 (registry+https://github.com/rust-lang/crates.io-index)",
"serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",

[3.92763]

[3.92906]

"ryu 0.2.7 (registry+https://github.com/rust-lang/crates.io-index)",
"serde 1.0.90 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1178

[3.92936]→[2.62942:62960](∅→∅)

version = "0.7.0"

[3.92936]

[3.92954]

version = "0.8.1"
replacement in Cargo.lock at line 1181

[3.93036]→[2.62961:63190](∅→∅)

"block-buffer 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
"byte-tools 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
"digest 0.7.6 (registry+https://github.com/rust-lang/crates.io-index)",

[3.93036]

[3.93188]

"block-buffer 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
"digest 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
edit in Cargo.lock at line 1184

[3.93264]

[3.93343]

"opaque-debug 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1189

[3.93372]→[2.63191:63209](∅→∅)

version = "0.7.1"

[3.93372]

[3.93390]

version = "0.8.0"
replacement in Cargo.lock at line 1192

[3.93472]→[2.63210:63439](∅→∅)

"block-buffer 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
"byte-tools 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
"digest 0.7.6 (registry+https://github.com/rust-lang/crates.io-index)",

[3.93472]

[3.93624]

"block-buffer 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
"digest 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
edit in Cargo.lock at line 1195

[3.93700]

[3.93779]

"opaque-debug 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1200

[3.93808]→[2.63440:63458](∅→∅)

version = "0.7.3"

[3.93808]

[3.93826]

version = "0.8.1"
replacement in Cargo.lock at line 1203

[3.93908]→[2.63459:63688](∅→∅)

"block-buffer 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
"byte-tools 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
"digest 0.7.6 (registry+https://github.com/rust-lang/crates.io-index)",

[3.93908]

[3.94137]

"block-buffer 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
"byte-tools 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
"digest 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
edit in Cargo.lock at line 1207

[3.94210]

[3.94289]

"opaque-debug 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1212

[3.94325]→[2.63689:63707](∅→∅)

version = "0.1.5"

[3.94325]

[3.94343]

version = "0.1.8"
replacement in Cargo.lock at line 1215

[3.94425]→[2.63708:63855](∅→∅)

"arc-swap 0.3.4 (registry+https://github.com/rust-lang/crates.io-index)",
"libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",

[3.94425]

[3.94573]

"arc-swap 0.3.10 (registry+https://github.com/rust-lang/crates.io-index)",
"libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1226

[3.94717]→[2.63856:63874](∅→∅)

version = "0.4.1"

[3.94717]

[3.94735]

version = "0.4.2"
replacement in Cargo.lock at line 1231

[3.94831]→[2.63875:63893](∅→∅)

version = "0.6.5"

[3.94831]

[3.94849]

version = "0.6.9"
edit in Cargo.lock at line 1233

[3.94914]→[2.63894:63991](∅→∅)

dependencies = [
"unreachable 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
replacement in Cargo.lock at line 1239

[3.95044]→[2.63992:64291](∅→∅)

"cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
"libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
"redox_syscall 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)",
"winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",

[3.95044]

[3.95343]

"cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
"libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
"redox_syscall 0.1.54 (registry+https://github.com/rust-lang/crates.io-index)",
"winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1252

[3.95498]→[2.64292:64310](∅→∅)

version = "0.1.1"

[3.95498]

[3.95516]

version = "0.1.3"
replacement in Cargo.lock at line 1260

[3.95716]→[2.64311:64555](∅→∅)

"lazy_static 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
"new_debug_unreachable 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
"phf_shared 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",

[3.95716]

[3.95960]

"lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
"new_debug_unreachable 1.0.3 (registry+https://github.com/rust-lang/crates.io-index)",
"phf_shared 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1264

[3.96043]→[2.64556:64629](∅→∅)

"serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",

[3.96043]

[3.96116]

"serde 1.0.90 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1274

[3.96434]→[2.64630:64940](∅→∅)

"phf_generator 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",
"phf_shared 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",
"proc-macro2 0.4.20 (registry+https://github.com/rust-lang/crates.io-index)",
"quote 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)",

[3.96434]

[3.96745]

"phf_generator 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)",
"phf_shared 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)",
"proc-macro2 0.4.27 (registry+https://github.com/rust-lang/crates.io-index)",
"quote 0.6.12 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1288

[3.96987]→[2.64941:64959](∅→∅)

version = "0.7.0"

[3.96987]

[3.97005]

version = "0.8.0"
source = "registry+https://github.com/rust-lang/crates.io-index"

[[package]]
name = "subtle"
version = "1.0.0"
replacement in Cargo.lock at line 1308

[3.97562]→[2.64960:64980](∅→∅)

version = "0.15.14"

[3.97562]

[3.97582]

version = "0.15.30"
replacement in Cargo.lock at line 1311

[3.97664]→[2.64981:65132](∅→∅)

"proc-macro2 0.4.20 (registry+https://github.com/rust-lang/crates.io-index)",
"quote 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)",

[3.97664]

[3.97816]

"proc-macro2 0.4.27 (registry+https://github.com/rust-lang/crates.io-index)",
"quote 0.6.12 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1326

[3.98140]→[2.65133:65152](∅→∅)

version = "0.10.0"

[3.98140]

[3.98159]

version = "0.10.1"
replacement in Cargo.lock at line 1329

[3.98241]→[2.65153:65376](∅→∅)

"proc-macro2 0.4.20 (registry+https://github.com/rust-lang/crates.io-index)",
"quote 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)",
"syn 0.15.14 (registry+https://github.com/rust-lang/crates.io-index)",

[3.98241]

[3.98465]

"proc-macro2 0.4.27 (registry+https://github.com/rust-lang/crates.io-index)",
"quote 0.6.12 (registry+https://github.com/rust-lang/crates.io-index)",
"syn 0.15.30 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1337

[3.98576]→[2.65377:65395](∅→∅)

version = "3.0.4"

[3.98576]

[3.98594]

version = "3.0.7"
replacement in Cargo.lock at line 1340

[3.98676]→[2.65396:65693](∅→∅)

"cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
"libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
"rand 0.5.5 (registry+https://github.com/rust-lang/crates.io-index)",
"redox_syscall 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)",

[3.98676]

[3.98973]

"cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
"libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
"rand 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)",
"redox_syscall 0.1.54 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1345

[3.99054]→[2.65694:65767](∅→∅)

"winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",

[3.99054]

[3.99127]

"winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1350

[3.99159]→[2.65768:65786](∅→∅)

version = "0.4.0"

[3.99159]

[3.99177]

version = "0.4.1"
replacement in Cargo.lock at line 1355

[3.99400]→[2.65787:65859](∅→∅)

"utf-8 0.7.4 (registry+https://github.com/rust-lang/crates.io-index)",

[3.99400]

[3.99472]

"utf-8 0.7.5 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1371

[3.99813]→[2.65860:66013](∅→∅)

"libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
"redox_syscall 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)",

[3.99813]

[3.99966]

"libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
"redox_syscall 0.1.54 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1378

[3.100079]→[2.66014:66033](∅→∅)

version = "0.10.0"

[3.100079]

[3.100098]

version = "0.11.0"
replacement in Cargo.lock at line 1389

[3.100397]→[2.66034:66112](∅→∅)

"lazy_static 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",

[3.100397]

[3.100475]

"lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1394

[3.100504]→[2.66113:66132](∅→∅)

version = "0.1.40"

[3.100504]

[3.100523]

version = "0.1.42"
replacement in Cargo.lock at line 1397

[3.100605]→[2.66133:66359](∅→∅)

"libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
"redox_syscall 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)",
"winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",

[3.100605]

[3.100831]

"libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
"redox_syscall 0.1.54 (registry+https://github.com/rust-lang/crates.io-index)",
"winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1404

[3.100861]→[2.66360:66379](∅→∅)

version = "0.1.11"

[3.100861]

[3.100880]

version = "0.1.18"
replacement in Cargo.lock at line 1407

[3.100962]→[2.66380:66528](∅→∅)

"bytes 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)",
"futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",

[3.100962]

[3.101110]

"bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
"futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
edit in Cargo.lock at line 1410

[3.101181]

[3.101257]

"num_cpus 1.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1412

[3.101335]→[2.66529:67317](∅→∅)

"tokio-current-thread 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-executor 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-fs 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-reactor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-tcp 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-threadpool 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-timer 0.2.7 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-udp 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-uds 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",

[3.101335]

[3.102285]

"tokio-current-thread 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-executor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-fs 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-io 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-reactor 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-sync 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-tcp 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-threadpool 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-timer 0.2.10 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-trace-core 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-udp 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-uds 0.2.5 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1431

[3.102423]→[2.67318:67393](∅→∅)

"futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",

[3.102423]

[3.102498]

"futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1439

[3.102634]→[2.67394:67618](∅→∅)

"bytes 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)",
"futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",

[3.102634]

[3.102858]

"bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
"futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-io 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1446

[3.102903]→[2.67619:67637](∅→∅)

version = "0.1.3"

[3.102903]

[3.102921]

version = "0.1.6"
replacement in Cargo.lock at line 1449

[3.103003]→[2.67638:67794](∅→∅)

"futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-executor 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",

[3.103003]

[3.103159]

"futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-executor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1455

[3.103198]→[2.67795:67813](∅→∅)

version = "0.1.5"

[3.103198]

[3.103216]

version = "0.1.7"
replacement in Cargo.lock at line 1458

[3.103298]→[2.67814:67889](∅→∅)

"futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",

[3.103298]

[3.103455]

"crossbeam-utils 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)",
"futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1464

[3.103488]→[2.67890:67908](∅→∅)

version = "0.1.4"

[3.103488]

[3.103506]

version = "0.1.6"
replacement in Cargo.lock at line 1467

[3.103588]→[2.67909:68143](∅→∅)

"futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-threadpool 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",

[3.103588]

[3.103823]

"futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-io 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-threadpool 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1474

[3.103856]→[2.68144:68163](∅→∅)

version = "0.1.10"

[3.103856]

[3.103875]

version = "0.1.12"
replacement in Cargo.lock at line 1477

[3.103957]→[2.68164:68382](∅→∅)

"bytes 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)",
"futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
"log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",

[3.103957]

[3.104175]

"bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
"futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
"log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1484

[3.104213]→[2.68383:68401](∅→∅)

version = "0.1.6"

[3.104213]

[3.104231]

version = "0.1.9"
replacement in Cargo.lock at line 1487

[3.104313]→[2.68402:68707](∅→∅)

"crossbeam-utils 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)",
"futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
"lazy_static 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
"log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",

[3.104313]

[3.104618]

"crossbeam-utils 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)",
"futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
"lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
"log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1492

[3.104689]→[2.68708:69089](∅→∅)

"num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
"parking_lot 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)",
"slab 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-executor 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",

[3.104689]

[3.105148]

"num_cpus 1.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
"parking_lot 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)",
"slab 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-executor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-io 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-sync 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1502

[3.105185]→[2.69090:69108](∅→∅)

version = "0.2.6"

[3.105185]

[3.105203]

version = "0.2.7"
replacement in Cargo.lock at line 1505

[3.105285]→[2.69109:69256](∅→∅)

"futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
"libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",

[3.105285]

[3.105432]

"futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
"libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1509

[3.105577]→[2.69257:69645](∅→∅)

"signal-hook 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-executor 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-reactor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
"winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",

[3.105577]

[3.105965]

"signal-hook 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-executor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-io 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-reactor 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
"winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
]

[[package]]
name = "tokio-sync"
version = "0.1.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"fnv 1.0.6 (registry+https://github.com/rust-lang/crates.io-index)",
"futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1527

[3.106279]→[2.69646:69664](∅→∅)

version = "0.1.2"

[3.106279]

[3.106297]

version = "0.1.3"
replacement in Cargo.lock at line 1530

[3.106379]→[2.69665:69813](∅→∅)

"bytes 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)",
"futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",

[3.106379]

[3.106527]

"bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
"futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1534

[3.106670]→[2.69814:69970](∅→∅)

"tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-reactor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",

[3.106670]

[3.106826]

"tokio-io 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-reactor 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1540

[3.106867]→[2.69971:69989](∅→∅)

version = "0.1.8"

[3.106867]

[3.106886]

version = "0.1.13"
replacement in Cargo.lock at line 1543

[3.106968]→[2.69990:70526](∅→∅)

"crossbeam-deque 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
"crossbeam-utils 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)",
"futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
"log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
"num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
"rand 0.5.5 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-executor 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",

[3.106968]

[3.107658]

"crossbeam-deque 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)",
"crossbeam-queue 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
"crossbeam-utils 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)",
"futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
"log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
"num_cpus 1.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
"rand 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)",
"slab 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-executor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1556

[3.107694]→[2.70527:70545](∅→∅)

version = "0.2.7"

[3.107694]

[3.107713]

version = "0.2.10"
replacement in Cargo.lock at line 1559

[3.107795]→[2.70546:70855](∅→∅)

"crossbeam-utils 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)",
"futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
"slab 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-executor 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",

[3.107795]

[3.108104]

"crossbeam-utils 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)",
"futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
"slab 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-executor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1567

[3.108138]→[2.70856:70874](∅→∅)

version = "0.2.0"

[3.108138]

[3.108156]

version = "0.2.1"
replacement in Cargo.lock at line 1570

[3.108238]→[2.70875:70950](∅→∅)

"futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",

[3.108238]

[3.108313]

"futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1572

[3.108390]→[2.70951:71027](∅→∅)

"tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",

[3.108390]

[3.108466]

"tokio-io 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
]

[[package]]
name = "tokio-trace-core"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1585

[3.108719]→[2.71028:71046](∅→∅)

version = "0.1.2"

[3.108719]

[3.108737]

version = "0.1.3"
replacement in Cargo.lock at line 1588

[3.108819]→[2.71047:71265](∅→∅)

"bytes 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)",
"futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
"log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",

[3.108819]

[3.109037]

"bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
"futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
"log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1593

[3.109186]→[2.71266:71422](∅→∅)

"tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-reactor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",

[3.109186]

[3.109342]

"tokio-io 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-reactor 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1599

[3.109376]→[2.71423:71441](∅→∅)

version = "0.2.3"

[3.109376]

[3.109394]

version = "0.2.5"
replacement in Cargo.lock at line 1602

[3.109476]→[2.71442:71590](∅→∅)

"bytes 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)",
"futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",

[3.109476]

[3.109624]

"bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
"futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1605

[3.109696]→[2.71591:71733](∅→∅)

"libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
"log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",

[3.109696]

[3.109838]

"libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
"log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1609

[3.109983]→[2.71734:71890](∅→∅)

"tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-reactor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",

[3.109983]

[3.110217]

"tokio-codec 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-io 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-reactor 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1616

[3.110252]→[2.71891:71909](∅→∅)

version = "0.2.0"

[3.110252]

[3.110270]

version = "1.0.0"
replacement in Cargo.lock at line 1619

[3.110352]→[2.71910:71983](∅→∅)

"bytes 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)",

[3.110352]

[3.110425]

"bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1621

[3.110504]→[2.71984:72059](∅→∅)

"futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",

[3.110504]

[3.110579]

"futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
edit in Cargo.lock at line 1623

[3.110650]→[2.72060:72204](∅→∅)

"jid 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)",
"minidom 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1624

[3.110727]→[2.72205:72426](∅→∅)

"quick-xml 0.12.4 (registry+https://github.com/rust-lang/crates.io-index)",
"sasl 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",

[3.110727]

[3.110948]

"quick-xml 0.13.3 (registry+https://github.com/rust-lang/crates.io-index)",
"sasl 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio 0.1.18 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1628

[3.111026]→[2.72427:72977](∅→∅)

"tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-tls 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
"trust-dns-proto 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)",
"trust-dns-resolver 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)",
"try_from 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
"xml5ever 0.12.0 (registry+https://github.com/rust-lang/crates.io-index)",
"xmpp-parsers 0.11.1 (registry+https://github.com/rust-lang/crates.io-index)",

[3.111026]

[3.111502]

"tokio-io 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-tls 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
"trust-dns-proto 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
"trust-dns-resolver 0.10.3 (registry+https://github.com/rust-lang/crates.io-index)",
"xml5ever 0.12.1 (registry+https://github.com/rust-lang/crates.io-index)",
"xmpp-parsers 0.12.2 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1638

[3.111531]→[2.72978:72996](∅→∅)

version = "0.4.8"

[3.111531]

[3.111549]

version = "0.5.0"
replacement in Cargo.lock at line 1641

[3.111631]→[2.72997:73070](∅→∅)

"serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",

[3.111631]

[3.111704]

"serde 1.0.90 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1646

[3.111744]→[2.73071:73089](∅→∅)

version = "0.4.3"

[3.111744]

[3.111762]

version = "0.6.3"
replacement in Cargo.lock at line 1649

[3.111844]→[2.73090:73320](∅→∅)

"byteorder 1.2.7 (registry+https://github.com/rust-lang/crates.io-index)",
"error-chain 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
"futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",

[3.111844]

[3.112069]

"byteorder 1.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
"failure 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
"futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1653

[3.112140]→[2.73321:73615](∅→∅)

"lazy_static 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
"log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
"rand 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)",
"smallvec 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)",

[3.112140]

[3.112434]

"lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
"log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
"rand 0.5.6 (registry+https://github.com/rust-lang/crates.io-index)",
"smallvec 0.6.9 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1658

[3.112508]→[2.73616:74153](∅→∅)

"tokio-executor 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-reactor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-tcp 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-timer 0.2.7 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-udp 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
"url 1.7.1 (registry+https://github.com/rust-lang/crates.io-index)",

[3.112508]

[3.113046]

"tokio-executor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-io 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-reactor 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-tcp 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-timer 0.2.10 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-udp 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
"url 1.7.2 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1669

[3.113089]→[2.74154:74172](∅→∅)

version = "0.9.1"

[3.113089]

[3.113108]

version = "0.10.3"
replacement in Cargo.lock at line 1672

[3.113190]→[2.74173:75007](∅→∅)

"cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
"error-chain 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
"futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
"ipconfig 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
"lazy_static 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
"log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
"lru-cache 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
"resolv-conf 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
"smallvec 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
"trust-dns-proto 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)",

[3.113190]

[3.114019]

"cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
"failure 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
"futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
"ipconfig 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
"lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
"log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
"lru-cache 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
"resolv-conf 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)",
"smallvec 0.6.9 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio 0.1.18 (registry+https://github.com/rust-lang/crates.io-index)",
"trust-dns-proto 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1692

[3.114166]→[2.75008:75026](∅→∅)

version = "0.2.2"

[3.114166]

[3.114184]

version = "0.3.2"
edit in Cargo.lock at line 1694

[3.114249]

[3.114341]

dependencies = [
"cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
]
replacement in Cargo.lock at line 1705

[3.114486]→[2.75027:75045](∅→∅)

version = "0.1.1"

[3.114486]

[3.114504]

version = "0.1.3"
replacement in Cargo.lock at line 1718

[3.114824]→[2.75046:75064](∅→∅)

version = "0.1.7"

[3.114824]

[3.114842]

version = "0.1.8"
edit in Cargo.lock at line 1720

[3.114907]

[3.115001]

dependencies = [
"smallvec 0.6.9 (registry+https://github.com/rust-lang/crates.io-index)",
]
edit in Cargo.lock at line 1740

[3.115350]→[2.75065:75272](∅→∅)

name = "unreachable"
version = "1.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"void 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)",
]

[[package]]
replacement in Cargo.lock at line 1741

[3.115363]→[2.75273:75291](∅→∅)

version = "1.7.1"

[3.115363]

[3.115381]

version = "1.7.2"
replacement in Cargo.lock at line 1751

[3.115721]→[2.75292:75310](∅→∅)

version = "0.7.4"

[3.115721]

[3.115739]

version = "0.7.5"
replacement in Cargo.lock at line 1756

[3.115838]→[2.75311:75329](∅→∅)

version = "1.0.1"

[3.115838]

[3.115856]

version = "1.0.2"
edit in Cargo.lock at line 1767

[3.116080]→[2.75330:75559](∅→∅)

source = "registry+https://github.com/rust-lang/crates.io-index"

[[package]]
name = "version_check"
version = "0.1.5"
source = "registry+https://github.com/rust-lang/crates.io-index"

[[package]]
name = "void"
version = "1.0.2"
replacement in Cargo.lock at line 1774

[3.116272]→[2.75560:75705](∅→∅)

"futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
"log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",

[3.116272]

[3.116417]

"futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
"log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1791

[3.116751]→[2.75706:75724](∅→∅)

version = "0.3.6"

[3.116751]

[3.116769]

version = "0.3.7"
replacement in Cargo.lock at line 1810

[3.117325]→[2.75725:75743](∅→∅)

version = "0.1.1"

[3.117325]

[3.117343]

version = "0.1.2"
replacement in Cargo.lock at line 1813

[3.117425]→[2.75744:75817](∅→∅)

"winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",

[3.117425]

[3.117498]

"winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1826

[3.117765]→[2.75818:75969](∅→∅)

"winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
"winapi-util 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",

[3.117765]

[3.117916]

"winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
"winapi-util 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1835

[3.118047]→[2.75970:76043](∅→∅)

"winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",

[3.118047]

[3.118120]

"winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1843

[3.118252]→[2.76044:76117](∅→∅)

"winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",

[3.118252]

[3.118325]

"winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1857

[3.118645]→[2.76118:76137](∅→∅)

version = "0.12.0"

[3.118645]

[3.118664]

version = "0.12.1"
replacement in Cargo.lock at line 1860

[3.118746]→[2.76138:76208](∅→∅)

"log 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",

[3.118746]

[3.118816]

"log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1862

[3.118886]→[2.76209:76359](∅→∅)

"markup5ever 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)",
"time 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)",

[3.118886]

[3.119036]

"markup5ever 0.7.5 (registry+https://github.com/rust-lang/crates.io-index)",
"time 0.1.42 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1868

[3.119073]→[2.76360:76379](∅→∅)

version = "0.11.1"

[3.119073]

[3.119092]

version = "0.12.2"
replacement in Cargo.lock at line 1871

[3.119174]→[2.76380:76526](∅→∅)

"base64 0.9.3 (registry+https://github.com/rust-lang/crates.io-index)",
"blake2 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)",

[3.119174]

[3.120186]

"base64 0.10.1 (registry+https://github.com/rust-lang/crates.io-index)",
"blake2 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1874

[3.120259]→[2.76527:77033](∅→∅)

"digest 0.7.6 (registry+https://github.com/rust-lang/crates.io-index)",
"jid 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)",
"minidom 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)",
"sha-1 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
"sha2 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)",
"sha3 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)",
"try_from 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",

[3.120259]

[3.120691]

"digest 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
"jid 0.5.3 (registry+https://github.com/rust-lang/crates.io-index)",
"minidom 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
"sha-1 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)",
"sha2 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
"sha3 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)",
"try_from 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
]

[[package]]
name = "xmpp-parsers"
version = "0.13.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"base64 0.10.1 (registry+https://github.com/rust-lang/crates.io-index)",
"blake2 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
"chrono 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
"digest 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
"jid 0.5.3 (registry+https://github.com/rust-lang/crates.io-index)",
"minidom 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
"sha-1 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)",
"sha2 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
"sha3 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1900

[3.120705]→[2.77034:77189](∅→∅)

"checksum aho-corasick 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)" = "68f56c7353e5a9547cbd76ed90f7bb5ffc3ba09d4ea9bd1d8c06c8b1142eeb5a"

[3.120705]

[3.121015]

"checksum MacTypes-sys 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "eaf9f0d0b1cc33a4d2aee14fb4b2eac03462ef4db29c8ac4057327d8a71ad86f"
"checksum aho-corasick 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)" = "e6f484ae0c99fec2e858eb6134949117399f222608d84cadb3f58c1f97c2364c"
replacement in Cargo.lock at line 1903

[3.121168]→[2.77190:77643](∅→∅)

"checksum arc-swap 0.3.4 (registry+https://github.com/rust-lang/crates.io-index)" = "af192669a9f44d2fb63c691a04183c8e12428f34041449270b08c0456587f5a5"
"checksum arrayref 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)" = "0d382e583f07208808f6b1249e60848879ba3543f57c32277bf52d69c2f0f0ee"
"checksum arrayvec 0.4.7 (registry+https://github.com/rust-lang/crates.io-index)" = "a1e964f9e24d588183fcb43503abda40d288c8657dfc27311516ce2f05675aef"

[3.121168]

[3.121472]

"checksum arc-swap 0.3.10 (registry+https://github.com/rust-lang/crates.io-index)" = "a57a5698f85c6fd92f19dad87ff2d822fc4ba79dd85c13914d8c4dad589cb815"
"checksum arrayvec 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)" = "92c7fb76bc8826a8b33b4ee5bb07a247a81e76764ab4d55e8f73e3a4d8808c71"
replacement in Cargo.lock at line 1906

[3.121620]→[2.77644:78254](∅→∅)

"checksum backtrace 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)" = "346d7644f0b5f9bc73082d3b2236b69a05fd35cce0cfa3724e184e6a5c9e2a2f"
"checksum backtrace 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)" = "89a47830402e9981c5c41223151efcced65a0510c13097c769cede7efb34782a"
"checksum backtrace-sys 0.1.24 (registry+https://github.com/rust-lang/crates.io-index)" = "c66d56ac8dabd07f6aacdaf633f4b8262f5b3601a810a0dcddffd5c22c69daa0"
"checksum base64 0.9.3 (registry+https://github.com/rust-lang/crates.io-index)" = "489d6c0ed21b11d038c31b6ceccca973e65d73ba3bd8ecb9a2babf5546164643"

[3.121620]

[3.122230]

"checksum autocfg 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "a6d640bee2da49f60a4068a7fae53acde8982514ab7bae8b8cea9e88cbcfd799"
"checksum backtrace 0.3.15 (registry+https://github.com/rust-lang/crates.io-index)" = "f106c02a3604afcdc0df5d36cc47b44b55917dbaf3d808f71c163a0ddba64637"
"checksum backtrace-sys 0.1.28 (registry+https://github.com/rust-lang/crates.io-index)" = "797c830ac25ccc92a7f8a7b9862bde440715531514594a6154e3d4a54dd769b6"
"checksum base64 0.10.1 (registry+https://github.com/rust-lang/crates.io-index)" = "0b25d992356d2eb0ed82172f5248873db5560c4721f564b13cb5193bda5e668e"
replacement in Cargo.lock at line 1911

[3.122381]→[2.78255:79013](∅→∅)

"checksum blake2 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)" = "73b77e29dbd0115e43938be2d5128ecf81c0353e00acaa65339a1242586951d9"
"checksum block-buffer 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)" = "a076c298b9ecdb530ed9d967e74a6027d6a7478924520acddcddc24c1c8ab3ab"
"checksum byte-tools 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "560c32574a12a89ecd91f5e742165893f86e3ab98d21f8ea548658eb9eef5f40"
"checksum byteorder 1.2.7 (registry+https://github.com/rust-lang/crates.io-index)" = "94f88df23a25417badc922ab0f5716cc1330e87f71ddd9203b3a3ccd9cedf75d"
"checksum bytes 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)" = "0ce55bd354b095246fc34caf4e9e242f5297a7fd938b090cadfea6eee614aa62"

[3.122381]

[3.123295]

"checksum blake2 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "91721a6330935673395a0607df4d49a9cb90ae12d259f1b3e0a3f6e1d486872e"
"checksum block-buffer 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "49665c62e0e700857531fa5d3763e91b539ff1abeebd56808d378b495870d60d"
"checksum block-padding 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "d75255892aeb580d3c566f213a2b6fdc1c66667839f45719ee1d30ebf2aea591"
"checksum byte-tools 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "e3b5ca7a04898ad4bcd41c90c5285445ff5b791899bb1b0abdd2a2aa791211d7"
"checksum byteorder 1.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "a019b10a2a7cdeb292db131fc8113e57ea2a908f6e7894b0c3c671893b65dbeb"
"checksum bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)" = "206fdffcfa2df7cbe15601ef46c813fce0965eb3286db6b56c583b814b51c81c"
replacement in Cargo.lock at line 1918

[3.123442]→[2.79014:79309](∅→∅)

"checksum cc 1.0.25 (registry+https://github.com/rust-lang/crates.io-index)" = "f159dfd43363c4d08055a07703eb7a3406b0dac4d0584d96965a3262db3c9d16"
"checksum cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)" = "082bb9b28e00d3c9d39cc03e64ce4cea0f1bb9b3fde493f0cbc008472d22bdf4"

[3.123442]

[3.123737]

"checksum cc 1.0.35 (registry+https://github.com/rust-lang/crates.io-index)" = "5e5f3fee5eeb60324c2781f1e41286bdee933850fff9b3c672587fed5ec58c83"
"checksum cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)" = "11d43355396e872eefb45ce6342e4374ed7bc2b3a502d1b28e36d6e23c05d1f4"
replacement in Cargo.lock at line 1921

[3.123886]→[2.79310:79458](∅→∅)

"checksum clap 2.32.0 (registry+https://github.com/rust-lang/crates.io-index)" = "b957d88f4b6a63b9d70d5f454ac8011819c6efa7727858f458ab71c756ce2d3e"

[3.123886]

[3.124034]

"checksum clap 2.33.0 (registry+https://github.com/rust-lang/crates.io-index)" = "5067f5bb2d80ef5d68b4c87db81601f0b75bca627bc2ef76b141d7b846a3c6d9"
edit in Cargo.lock at line 1923

[3.124185]→[2.79459:79618](∅→∅)

"checksum constant_time_eq 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "8ff012e225ce166d4422e0e78419d901719760f62ae2b7969ca6b564d1b54a9e"
replacement in Cargo.lock at line 1925

[3.124505]→[2.79619:80400](∅→∅)

"checksum crossbeam-deque 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)" = "3486aefc4c0487b9cb52372c97df0a48b8c249514af1ee99703bf70d2f2ceda1"
"checksum crossbeam-epoch 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)" = "30fecfcac6abfef8771151f8be4abc9e4edc112c2bcb233314cafde2680536e9"
"checksum crossbeam-utils 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)" = "677d453a17e8bd2b913fa38e8b9cf04bcdbb5be790aa294f2389661d72036015"
"checksum crypto-mac 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)" = "0999b4ff4d3446d4ddb19a63e9e00c1876e75cd7000d20e57a693b4b3f08d958"
"checksum dbghelp-sys 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "97590ba53bcb8ac28279161ca943a924d1fd4a8fb3fa63302591647c4fc5b850"

[3.124505]

[3.125290]

"checksum crossbeam-deque 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)" = "b18cd2e169ad86297e6bc0ad9aa679aee9daa4f19e8163860faf7c164e4f5a71"
"checksum crossbeam-epoch 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)" = "04c9e3102cc2d69cd681412141b390abd55a362afc1540965dad0ad4d34280b4"
"checksum crossbeam-queue 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "7c979cd6cfe72335896575c6b5688da489e420d36a27a0b9eb0c73db574b4a4b"
"checksum crossbeam-utils 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)" = "f8306fcef4a7b563b76b7dd949ca48f52bc1141aa067d2ea09565f3e2652aa5c"
"checksum crypto-mac 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "4434400df11d95d556bac068ddfedd482915eb18fe8bea89bc80b6e4b1c179e5"
replacement in Cargo.lock at line 1931

[3.125445]→[2.80401:81014](∅→∅)

"checksum digest 0.7.6 (registry+https://github.com/rust-lang/crates.io-index)" = "03b072242a8cbaf9c145665af9d250c59af3b958f83ed6824e13533cf76d5b90"
"checksum encoding_rs 0.8.10 (registry+https://github.com/rust-lang/crates.io-index)" = "065f4d0c826fdaef059ac45487169d918558e3cf86c9d89f6e81cf52369126e5"
"checksum env_logger 0.5.13 (registry+https://github.com/rust-lang/crates.io-index)" = "15b0a4d2e39f8420210be8b27eeda28029729e2fd4291019455016c348240c38"
"checksum error-chain 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)" = "faa976b4fd2e4c2b2f3f486874b19e61944d3de3de8b61c9fcf835d583871bcc"

[3.125445]

[3.125902]

"checksum digest 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "05f47366984d3ad862010e22c7ce81a7dbcaebbdfb37241a620f8b6596ee135c"
"checksum encoding_rs 0.8.17 (registry+https://github.com/rust-lang/crates.io-index)" = "4155785c79f2f6701f185eb2e6b4caf0555ec03477cb4c70db67b465311620ed"
"checksum env_logger 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)" = "b61fa891024a945da30a9581546e8cfaf5602c7b3f4c137a2805cf388f92075a"
replacement in Cargo.lock at line 1935

[3.126056]→[2.81015:81322](∅→∅)

"checksum failure 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "6dd377bcc1b1b7ce911967e3ec24fa19c3224394ec05b54aa7b083d498341ac7"
"checksum failure_derive 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "64c2d913fe8ed3b6c6518eedf4538255b989945c14c2a7d5cbff62a5e2120596"

[3.126056]

[3.126363]

"checksum failure 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "795bd83d3abeb9220f257e597aa0080a508b27533824adf336529648f6abf7e2"
"checksum failure_derive 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "ea1063915fd7ef4309e222a5a07cf9c319fb9c7836b1f89b85458672dbb127e1"
edit in Cargo.lock at line 1941

[3.126980]

[3.127136]

"checksum fuchsia-cprng 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "a06f77d526c1a601b7c4cdd98f54b5eaabffc14d5f2f0296febdc7f357c6d3ba"
replacement in Cargo.lock at line 1945

[3.127601]→[2.81323:81474](∅→∅)

"checksum futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)" = "49e7653e374fe0d0c12de4250f0bdb60680b8c80eed558c5c7538eec9c89e21b"

[3.127601]

[3.127752]

"checksum futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)" = "62941eff9507c8177d448bd83a44d9b9760856e184081d8cd79ba9f03dd24981"
replacement in Cargo.lock at line 1947

[3.127910]→[2.81475:81777](∅→∅)

"checksum generic-array 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ef25c5683767570c2bbd7deba372926a55eaae9982d7726ee2a1050239d45b9d"
"checksum h2 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)" = "7dd33bafe2e6370e6c8eb0cf1b8c5f93390b90acde7e9b03723f166b28b648ed"

[3.127910]

[3.128360]

"checksum generic-array 0.12.0 (registry+https://github.com/rust-lang/crates.io-index)" = "3c0f28c2f5bfb5960175af447a2da7c18900693738343dc896ffbcabd9839592"
"checksum h2 0.1.18 (registry+https://github.com/rust-lang/crates.io-index)" = "85ab6286db06040ddefb71641b50017c06874614001a134b423783e2db2920bd"
"checksum hmac 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "f127a908633569f208325f86f71255d3363c79721d7f9fe31cd5569908819771"
replacement in Cargo.lock at line 1951

[3.128511]→[2.81778:81926](∅→∅)

"checksum http 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)" = "24f58e8c2d8e886055c3ead7b28793e1455270b5fb39650984c224bc538ba581"

[3.128511]

[3.128659]

"checksum http 0.1.17 (registry+https://github.com/rust-lang/crates.io-index)" = "eed324f0f0daf6ec10c474f150505af2c143f251722bf9dbd1261bd1f2ee2c1a"
replacement in Cargo.lock at line 1953

[3.128810]→[2.81927:82229](∅→∅)

"checksum humantime 1.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "0484fda3e7007f2a4a0d9c3a703ca38c71c54c55602ce4660c419fd32e188c9e"
"checksum hyper 0.12.13 (registry+https://github.com/rust-lang/crates.io-index)" = "95ffee0d1d30de4313fdaaa485891ce924991d45bbc18adfc8ac5b1639e62fbb"

[3.128810]

[3.129112]

"checksum humantime 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "3ca7e5f2e110db35f93b837c81797f3714500b81d517bf20c431b16d3ca4f114"
"checksum hyper 0.12.27 (registry+https://github.com/rust-lang/crates.io-index)" = "4f2777434f26af6e4ce4fdcdccd3bed9d861d11e87bcbe72c0f51ddaca8ff848"
replacement in Cargo.lock at line 1958

[3.129558]→[2.82230:82381](∅→∅)

"checksum ipconfig 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)" = "fccb81dd962b29a25de46c4f46e497b75117aa816468b6fff7a63a598a192394"

[3.129558]

[3.129709]

"checksum ipconfig 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)" = "08f7eadeaf4b52700de180d147c4805f199854600b36faa963d91114827b2ffc"
replacement in Cargo.lock at line 1960

[3.129856]→[2.82382:82528](∅→∅)

"checksum jid 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)" = "6c4cee633b7ce95e71202ecb99e632d15ad468de7753e616a924c93842f1a3d0"

[3.129856]

[3.130002]

"checksum jid 0.5.3 (registry+https://github.com/rust-lang/crates.io-index)" = "24e8a3f2ab860aa08074136e3144a2425e678d8823206e5adcc6145dc136503a"
replacement in Cargo.lock at line 1963

[3.130306]→[2.82529:83735](∅→∅)

"checksum lazy_static 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ca488b89a5657b0a2ecd45b95609b3e848cf1755da332a0da46e2b2b1cb371a7"
"checksum lazycell 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ddba4c30a78328befecec92fc94970e53b3ae385827d28620f0f5bb2493081e0"
"checksum libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)" = "76e3a3ef172f1a0b9a9ff0dd1491ae5e6c948b94479a3021819ba7d860c8645d"
"checksum linked-hash-map 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)" = "7860ec297f7008ff7a1e3382d7f7e1dcd69efc94751a2284bafc3d013c2aa939"
"checksum lock_api 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)" = "775751a3e69bde4df9b38dd00a1b5d6ac13791e4223d4a0506577f0dd27cfb7a"
"checksum log 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)" = "e19e8d5c34a3e0e2223db8e060f9e8264aeeb5c5fc64a4ee9965c062211c024b"
"checksum log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)" = "d4fcce5fa49cc693c312001daf1d13411c4a5283796bac1084299ea3e567113f"
"checksum lru-cache 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "4d06ff7ff06f729ce5f4e227876cb88d10bc59cd4ae1e09fbb2bde15c850dc21"

[3.130306]

[3.131366]

"checksum lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "bc5729f27f159ddd61f4df6228e827e86643d4d3e7c32183cb30a1c08f604a14"
"checksum lazycell 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "b294d6fa9ee409a054354afc4352b0b9ef7ca222c69b8812cbea9e7d2bf3783f"
"checksum libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)" = "bedcc7a809076656486ffe045abeeac163da1b558e963a31e29fbfbeba916917"
"checksum linked-hash-map 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)" = "ae91b68aebc4ddb91978b11a1b02ddd8602a05ec19002801c5666000e05e0f83"
"checksum lock_api 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "62ebf1391f6acad60e5c8b43706dde4582df75c06698ab44511d15016bc2442c"
"checksum log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)" = "c84ec4b527950aa83a329754b01dbe3f58361d1c5efacd1f6d68c494d08a17c6"
"checksum lru-cache 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "31e24f1ad8321ca0e8a1e0ac13f23cb668e6f5466c2c57319f6a5cf1cc8e3b1c"
replacement in Cargo.lock at line 1971

[3.131512]→[2.83736:83890](∅→∅)

"checksum markup5ever 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)" = "a87c4100d614080c8ab43334fb028ebe387f273fb61ed4ff0eae9189b94b6be8"

[3.131512]

[3.131666]

"checksum markup5ever 0.7.5 (registry+https://github.com/rust-lang/crates.io-index)" = "897636f9850c3eef4905a5540683ed53dc9393860f0846cab2c2ddf9939862ff"
replacement in Cargo.lock at line 1973

[3.131816]→[2.83891:84040](∅→∅)

"checksum memchr 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "4b3629fe9fdbff6daa6c33b90f7c08355c1aca05a3d01fa8063b822fcf185f3b"

[3.131816]

[3.131965]

"checksum memchr 2.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "2efc7bc57c883d4a4d6e3246905283d8dae951bb3bd32f49d6ef297f546e1c39"
replacement in Cargo.lock at line 1975

[3.132117]→[2.84041:84191](∅→∅)

"checksum minidom 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)" = "c0a5296bf9d0ac9e4a6e4cb844e3ee84bf33f841c7b3ae2cc87f05ceb81b50ae"

[3.132117]

[3.132268]

"checksum minidom 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)" = "275024eea6c6ff4ace22f2750843831183785288eec1cff91a4e6b8898cf94f9"
replacement in Cargo.lock at line 1981

[3.133013]→[2.84192:84506](∅→∅)

"checksum new_debug_unreachable 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)" = "0cdc457076c78ab54d5e0d6fa7c47981757f1e34dc39ff92787f217dede586c4"
"checksum nodrop 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)" = "9a2228dca57108069a5262f2ed8bd2e82496d2e074a06d1ccc7ce1687b6ae0a2"

[3.133013]

[3.133327]

"checksum new_debug_unreachable 1.0.3 (registry+https://github.com/rust-lang/crates.io-index)" = "f40f005c60db6e03bae699e414c58bf9aa7ea02a2d0b9bfbcf19286cc4c82b30"
"checksum nodrop 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)" = "2f9667ddcc6cc8a43afc9b7917599d7216aa09c463919ea32c59ed6cac8bc945"
replacement in Cargo.lock at line 1985

[3.133635]→[2.84507:84810](∅→∅)

"checksum num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "c51a3322e4bca9d212ad9a158a02abc6934d005490c054a2778df73a70aa0a30"
"checksum openssl 0.10.15 (registry+https://github.com/rust-lang/crates.io-index)" = "5e1309181cdcbdb51bc3b6bedb33dfac2a83b3d585033d3f6d9e22e8c1928613"

[3.133635]

[3.134094]

"checksum num_cpus 1.10.0 (registry+https://github.com/rust-lang/crates.io-index)" = "1a23f0ed30a54abaa0c7e83b1d2d87ada7c3c23078d1d87815af3e3b6385fbba"
"checksum opaque-debug 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "93f5bb2e8e8dec81642920ccff6b61f1eb94fa3020c5a325c9851ff604152409"
"checksum openssl 0.10.20 (registry+https://github.com/rust-lang/crates.io-index)" = "5a0d6b781aac4ac1bd6cafe2a2f0ad8c16ae8e1dd5184822a16c50139f8838d9"
replacement in Cargo.lock at line 1989

[3.134250]→[2.84811:85432](∅→∅)

"checksum openssl-sys 0.9.39 (registry+https://github.com/rust-lang/crates.io-index)" = "278c1ad40a89aa1e741a1eed089a2f60b18fab8089c3139b542140fc7d674106"
"checksum owning_ref 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)" = "cdf84f41639e037b484f93433aa3897863b561ed65c6e59c7073d7c561710f37"
"checksum parking_lot 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)" = "f0802bff09003b291ba756dc7e79313e51cc31667e94afbe847def490424cde5"
"checksum parking_lot_core 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "ad7f7e6ebdc79edff6fdcb87a55b620174f7a989e3eb31b65231f4af57f00b8c"

[3.134250]

[3.135020]

"checksum openssl-sys 0.9.43 (registry+https://github.com/rust-lang/crates.io-index)" = "33c86834957dd5b915623e94f2f4ab2c70dd8f6b70679824155d5ae21dbd495d"
"checksum owning_ref 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "49a4b8ea2179e6a2e27411d3bca09ca6dd630821cf6894c6c7c8467a8ee7ef13"
"checksum parking_lot 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)" = "ab41b4aed082705d1056416ae4468b6ea99d52599ecf3169b00088d43113e337"
"checksum parking_lot_core 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "94c8c7923936b28d546dfd14d4472eaf34c99b14e1c973a32b3e6d4eb04298c9"
"checksum pbkdf2 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "006c038a43a45995a9670da19e67600114740e8511d4333bf97a56e66a7542d9"
replacement in Cargo.lock at line 1995

[3.135179]→[2.85433:86046](∅→∅)

"checksum phf 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)" = "cec29da322b242f4c3098852c77a0ca261c9c01b806cae85a5572a1eb94db9a6"
"checksum phf_codegen 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)" = "7d187f00cd98d5afbcd8898f6cf181743a449162aeb329dcd2f3849009e605ad"
"checksum phf_generator 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)" = "03dc191feb9b08b0dc1330d6549b795b9d81aec19efe6b4a45aec8d4caee0c4b"
"checksum phf_shared 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)" = "b539898d22d4273ded07f64a05737649dc69095d92cb87c7097ec68e3f150b93"

[3.135179]

[3.135792]

"checksum phf 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)" = "b3da44b85f8e8dfaec21adae67f95d93244b2ecf6ad2a692320598dcc8e6dd18"
"checksum phf_codegen 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)" = "b03e85129e324ad4166b06b2c7491ae27fe3ec353af72e72cd1654c7225d517e"
"checksum phf_generator 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)" = "09364cc93c159b8b06b1f4dd8a4398984503483891b0c26b867cf431fb132662"
"checksum phf_shared 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)" = "234f71a15de2288bcb7e3b6515828d22af7ec8598ee6d24c3b526fa0a80b67a0"
replacement in Cargo.lock at line 2001

[3.136105]→[2.86047:86202](∅→∅)

"checksum proc-macro2 0.4.20 (registry+https://github.com/rust-lang/crates.io-index)" = "3d7b7eaaa90b4a90a932a9ea6666c95a389e424eff347f0f793979289429feee"

[3.136105]

[3.136260]

"checksum proc-macro2 0.4.27 (registry+https://github.com/rust-lang/crates.io-index)" = "4d317f9caece796be1980837fd5cb3dfec5613ebdb04ad0956deea83ce168915"
replacement in Cargo.lock at line 2003

[3.136414]→[2.86203:86356](∅→∅)

"checksum quick-xml 0.12.4 (registry+https://github.com/rust-lang/crates.io-index)" = "1d8065cbb01701c11cc195cde85cbf39d1c6a80705b67a157ebb3042e0e5777f"

[3.136414]

[3.136567]

"checksum quick-xml 0.13.3 (registry+https://github.com/rust-lang/crates.io-index)" = "22fcc48ecef4609b243e8c01ff4695d08ee0fc9d5bdbc54630e1a5fe8bb40953"
replacement in Cargo.lock at line 2005

[3.136716]→[2.86357:87260](∅→∅)

"checksum quote 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)" = "dd636425967c33af890042c483632d33fa7a18f19ad1d7ea72e8998c6ef8dea5"
"checksum rand 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)" = "8356f47b32624fef5b3301c1be97e5944ecdd595409cc5da11d05f211db6cfbd"
"checksum rand 0.5.5 (registry+https://github.com/rust-lang/crates.io-index)" = "e464cd887e869cddcae8792a4ee31d23c7edd516700695608f5b98c67ee0131c"
"checksum rand_core 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "1961a422c4d189dfb50ffa9320bf1f2a9bd54ecb92792fb9477f99a1045f3372"
"checksum rand_core 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "0905b6b7079ec73b314d4c748701f6931eb79fd97c668caa3f1899b22b32c6db"
"checksum redox_syscall 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)" = "c214e91d3ecf43e9a4e41e578973adeb14b474f2bee858742d127af75a0112b1"

[3.136716]

[3.138837]

"checksum quote 0.6.12 (registry+https://github.com/rust-lang/crates.io-index)" = "faf4799c5d274f3868a4aae320a0a182cbd2baee377b378f080e16a23e9d80db"
"checksum rand 0.5.6 (registry+https://github.com/rust-lang/crates.io-index)" = "c618c47cd3ebd209790115ab837de41425723956ad3ce2e6a7f09890947cacb9"
"checksum rand 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)" = "6d71dacdc3c88c1fde3885a3be3fbab9f35724e6ce99467f7d9c5026132184ca"
"checksum rand_chacha 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "556d3a1ca6600bfcbab7c7c91ccb085ac7fbbcd70e008a98742e7847f4f7bcef"
"checksum rand_core 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "7a6fdeb83b075e8266dcc8762c22776f6877a63111121f5f8c7411e5be7eed4b"
"checksum rand_core 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "d0e7a549d590831370895ab7ba4ea0c1b6b011d106b5ff2da6eee112615e6dc0"
"checksum rand_hc 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "7b40677c7be09ae76218dc623efbf7b18e34bced3f38883af07bb75630a21bc4"
"checksum rand_isaac 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "ded997c9d5f13925be2a6fd7e66bf1872597f759fd9dd93513dd7e92e5a5ee08"
"checksum rand_jitter 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "7b9ea758282efe12823e0d952ddb269d2e1897227e464919a554f2a03ef1b832"
"checksum rand_os 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "7b75f676a1e053fc562eafbb47838d67c84801e38fc1ba459e8f180deabd5071"
"checksum rand_pcg 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "abf9b09b01790cfe0364f52bf32995ea3c39f4d2dd011eac241d2914146d0b44"
"checksum rand_xorshift 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "cbf7e9e623549b0e21f6e97cf8ecf247c1a8fd2e8a992ae265314300b2455d5c"
"checksum rdrand 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "678054eb77286b51581ba43620cc911abf02758c91f93f479767aed0f90458b2"
"checksum redox_syscall 0.1.54 (registry+https://github.com/rust-lang/crates.io-index)" = "12229c14a0f65c4f1cb046a3b52047cdd9da1f4b30f8a39c5063c8bae515e252"
replacement in Cargo.lock at line 2020

[3.138993]→[2.87261:87564](∅→∅)

"checksum regex 1.0.5 (registry+https://github.com/rust-lang/crates.io-index)" = "2069749032ea3ec200ca51e4a31df41759190a88edca0d2d86ee8bedf7073341"
"checksum regex-syntax 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)" = "747ba3b235651f6e2f67dfa8bcdcd073ddb7c243cb21c442fc12395dfcac212d"

[3.138993]

[3.139296]

"checksum regex 1.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "559008764a17de49a3146b234641644ed37d118d1ef641a0bb573d146edc6ce0"
"checksum regex-syntax 0.6.6 (registry+https://github.com/rust-lang/crates.io-index)" = "dcfd8681eebe297b81d98498869d4aae052137651ad7b96822f09ceb690d0a96"
replacement in Cargo.lock at line 2023

[3.139453]→[2.87565:87876](∅→∅)

"checksum resolv-conf 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)" = "c62bd95a41841efdf7fca2ae9951e64a8d8eae7e5da196d8ce489a2241491a92"
"checksum rustc-demangle 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)" = "bcfe5b13211b4d78e5c2cadfebd7769197d95c639c35a50057eb4c05de811395"

[3.139453]

[3.139765]

"checksum resolv-conf 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)" = "b263b4aa1b5de9ffc0054a2386f96992058bb6870aab516f8cdeb8a667d56dcb"
"checksum rustc-demangle 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)" = "ccc78bfd5acd7bf3e89cffcf899e5cb1a52d6fafa8dec2739ad70c9577a57288"
replacement in Cargo.lock at line 2026

[3.139921]→[2.87877:88472](∅→∅)

"checksum ryu 0.2.6 (registry+https://github.com/rust-lang/crates.io-index)" = "7153dd96dade874ab973e098cb62fcdbb89a03682e46b144fd09550998d4a4a7"
"checksum safemem 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "8dca453248a96cb0749e36ccdfe2b0b4e54a61bfef89fb97ec621eb8e0a93dd9"
"checksum sasl 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)" = "4dbda5436dcd059da44fbf84b87a7164c5e3cad354efd0630c1f2be3c51c8859"
"checksum schannel 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)" = "0e1a231dc10abf6749cfa5d7767f25888d484201accbd919b66ab5413c502d56"

[3.139921]

[3.140366]

"checksum ryu 0.2.7 (registry+https://github.com/rust-lang/crates.io-index)" = "eb9e9b8cde282a9fe6a42dd4681319bfb63f121b8a8ee9439c6f4107e58a46f7"
"checksum sasl 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)" = "e457758c85b736bbad56dc099406cd2a9c19554cf81880dba7a51d092929e600"
"checksum schannel 0.1.15 (registry+https://github.com/rust-lang/crates.io-index)" = "f2f6abf258d99c3c1c5c2131d99d064e94b7b3dd5f416483057f308fea253339"
replacement in Cargo.lock at line 2030

[3.140519]→[2.88473:88799](∅→∅)

"checksum security-framework 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "697d3f3c23a618272ead9e1fb259c1411102b31c6af8b93f1d64cca9c3b0e8e0"
"checksum security-framework-sys 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "ab01dfbe5756785b5b4d46e0289e5a18071dfa9a7c2b24213ea00b9ef9b665bf"

[3.140519]

[3.140845]

"checksum security-framework 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "bfab8dda0e7a327c696d893df9ffa19cadc4bd195797997f5223cf5831beaf05"
"checksum security-framework-sys 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)" = "3d6696852716b589dff9e886ff83778bb635150168e83afa8ac6b8a78cb82abc"
replacement in Cargo.lock at line 2034

[3.141150]→[2.88800:89855](∅→∅)

"checksum serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)" = "15c141fc7027dd265a47c090bf864cf62b42c4d228bbcf4e51a0c9e2b0d3f7ef"
"checksum serde_derive 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)" = "225de307c6302bec3898c51ca302fc94a7a1697ef0845fcee6448f33c032249c"
"checksum serde_json 1.0.32 (registry+https://github.com/rust-lang/crates.io-index)" = "43344e7ce05d0d8280c5940cabb4964bea626aa58b1ec0e8c73fa2a8512a38ce"
"checksum sha-1 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "51b9d1f3b5de8a167ab06834a7c883bd197f2191e1dda1a22d9ccfeedbf9aded"
"checksum sha2 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)" = "9eb6be24e4c23a84d7184280d2722f7f2731fcdd4a9d886efbfe4413e4847ea0"
"checksum sha3 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)" = "b64dcef59ed4290b9fb562b53df07f564690d6539e8ecdd4728cf392477530bc"
"checksum signal-hook 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "f7ca1f1c0ed6c8beaab713ad902c041e4f09d06e1b4bb74c5fc553c078ed0110"

[3.141150]

[3.142205]

"checksum serde 1.0.90 (registry+https://github.com/rust-lang/crates.io-index)" = "aa5f7c20820475babd2c077c3ab5f8c77a31c15e16ea38687b4c02d3e48680f4"
"checksum serde_derive 1.0.90 (registry+https://github.com/rust-lang/crates.io-index)" = "58fc82bec244f168b23d1963b45c8bf5726e9a15a9d146a067f9081aeed2de79"
"checksum serde_json 1.0.39 (registry+https://github.com/rust-lang/crates.io-index)" = "5a23aa71d4a4d43fdbfaac00eff68ba8a06a51759a89ac3304323e800c4dd40d"
"checksum sha-1 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)" = "23962131a91661d643c98940b20fcaffe62d776a823247be80a48fcb8b6fce68"
"checksum sha2 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "7b4d8bfd0e469f417657573d8451fb33d16cfe0989359b93baf3a1ffc639543d"
"checksum sha3 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)" = "34a5e54083ce2b934bf059fdf38e7330a154177e029ab6c4e18638f2f624053a"
"checksum signal-hook 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)" = "97a47ae722318beceb0294e6f3d601205a1e6abaa4437d9d33e3a212233e3021"
replacement in Cargo.lock at line 2042

[3.142357]→[2.89856:90154](∅→∅)

"checksum slab 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)" = "5f9776d6b986f77b35c6cf846c11ad986ff128fe0b2b63a3628e3755e8d3102d"
"checksum smallvec 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)" = "153ffa32fd170e9944f7e0838edf824a754ec4c1fc64746fcc9fe1f8fa602e5d"

[3.142357]

[3.142655]

"checksum slab 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)" = "c111b5bd5695e56cffe5129854aa230b39c93a305372fdbb2668ca2394eea9f8"
"checksum smallvec 0.6.9 (registry+https://github.com/rust-lang/crates.io-index)" = "c4488ae950c49d403731982257768f48fada354a5203fe81f9bb6f43ca9002be"
replacement in Cargo.lock at line 2046

[3.142966]→[2.90155:90304](∅→∅)

"checksum string 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "00caf261d6f90f588f8450b8e1230fa0d5be49ee6140fdfbcb55335aff350970"

[3.142966]

[3.143115]

"checksum string 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "b639411d0b9c738748b5397d5ceba08e648f4f1992231aa859af1a017f31f60b"
replacement in Cargo.lock at line 2050

[3.143595]→[2.90305:90454](∅→∅)

"checksum strsim 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "bb4f380125926a99e52bc279241539c018323fab05ad6368b56f93d9369ff550"

[3.143595]

[3.143893]

"checksum strsim 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "8ea5119cdb4c55b55d432abb513a0429384878c15dde60cc77b1c99de1a95a6a"
"checksum subtle 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "2d67a5a62ba6e01cb2192ff309324cb4875d0c451d55fe2319433abe7a05a8ee"
replacement in Cargo.lock at line 2053

[3.144041]→[2.90455:90603](∅→∅)

"checksum syn 0.15.14 (registry+https://github.com/rust-lang/crates.io-index)" = "baaba45c6bf60fe29aaf241fa33306c0b75c801edea8378263a8f043b09a5634"

[3.144041]

[3.144189]

"checksum syn 0.15.30 (registry+https://github.com/rust-lang/crates.io-index)" = "66c8865bf5a7cbb662d8b011950060b3c8743dca141b054bf7195b20d314d8e2"
replacement in Cargo.lock at line 2055

[3.144338]→[2.90604:91061](∅→∅)

"checksum synstructure 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ec37f4fab4bafaf6b5621c1d54e6aa5d4d059a8f84929e87abfdd7f9f04c6db2"
"checksum tempfile 3.0.4 (registry+https://github.com/rust-lang/crates.io-index)" = "55c1195ef8513f3273d55ff59fe5da6940287a0d7a98331254397f464833675b"
"checksum tendril 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "9de21546595a0873061940d994bbbc5c35f024ae4fd61ec5c5b159115684f508"

[3.144338]

[3.144795]

"checksum synstructure 0.10.1 (registry+https://github.com/rust-lang/crates.io-index)" = "73687139bf99285483c96ac0add482c3776528beac1d97d444f6e91f203a2015"
"checksum tempfile 3.0.7 (registry+https://github.com/rust-lang/crates.io-index)" = "b86c784c88d98c801132806dadd3819ed29d8600836c4088e855cdf3e178ed8a"
"checksum tendril 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)" = "707feda9f2582d5d680d733e38755547a3e8fb471e7ba11452ecfd9ce93a5d3b"
replacement in Cargo.lock at line 2060

[3.145097]→[2.91062:91214](∅→∅)

"checksum textwrap 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)" = "307686869c93e71f94da64286f9a9524c0f308a9e1c87a583de8e9c9039ad3f6"

[3.145097]

[3.145249]

"checksum textwrap 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)" = "d326610f408c7a4eb6f51c37c330e496b08506c9457c9d34287ecc38809fb060"
replacement in Cargo.lock at line 2062

[3.145404]→[2.91215:91512](∅→∅)

"checksum time 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)" = "d825be0eb33fda1a7e68012d51e9c7f451dc1a69391e7fdc197060bb8c56667b"
"checksum tokio 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)" = "6e93c78d23cc61aa245a8acd2c4a79c4d7fa7fb5c3ca90d5737029f043a84895"

[3.145404]

[3.145701]

"checksum time 0.1.42 (registry+https://github.com/rust-lang/crates.io-index)" = "db8dcfca086c1143c9270ac42a2bbd8a7ee477b78ac8e45b19abfb0cbede4b6f"
"checksum tokio 0.1.18 (registry+https://github.com/rust-lang/crates.io-index)" = "65641e515a437b308ab131a82ce3042ff9795bef5d6c5a9be4eb24195c417fd9"
replacement in Cargo.lock at line 2066

[3.146011]→[2.91513:93987](∅→∅)

"checksum tokio-current-thread 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "f90fcd90952f0a496d438a976afba8e5c205fb12123f813d8ab3aa1c8436638c"
"checksum tokio-executor 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "c117b6cf86bb730aab4834f10df96e4dd586eff2c3c27d3781348da49e255bde"
"checksum tokio-fs 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)" = "60ae25f6b17d25116d2cba342083abe5255d3c2c79cb21ea11aa049c53bf7c75"
"checksum tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)" = "7392fe0a70d5ce0c882c4778116c519bd5dbaa8a7c3ae3d04578b3afafdcda21"
"checksum tokio-reactor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)" = "4b26fd37f1125738b2170c80b551f69ff6fecb277e6e5ca885e53eec2b005018"
"checksum tokio-signal 0.2.6 (registry+https://github.com/rust-lang/crates.io-index)" = "40da88e6445ed335e14746b60986a6c8b3632b09bc9097df76b4a6ddd16f1f92"
"checksum tokio-tcp 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "7ad235e9dadd126b2d47f6736f65aa1fdcd6420e66ca63f44177bc78df89f912"
"checksum tokio-threadpool 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)" = "3929aee321c9220ed838ed6c3928be7f9b69986b0e3c22c972a66dbf8a298c68"
"checksum tokio-timer 0.2.7 (registry+https://github.com/rust-lang/crates.io-index)" = "3a52f00c97fedb6d535d27f65cccb7181c8dd4c6edc3eda9ea93f6d45d05168e"
"checksum tokio-tls 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "e53fdbf3156f588be1676022fe794232b24922d426e8c14f4e46891c1e31c440"
"checksum tokio-udp 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "da941144b816d0dcda4db3a1ba87596e4df5e860a72b70783fe435891f80601c"
"checksum tokio-uds 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)" = "df195376b43508f01570bacc73e13a1de0854dc59e79d1ec09913e8db6dd2a70"
"checksum tokio-xmpp 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "c27385c4781afc851c61ac66d79463c511bf073d3a5d71b8bfd13a816e475989"
"checksum toml 0.4.8 (registry+https://github.com/rust-lang/crates.io-index)" = "4a2ecc31b0351ea18b3fe11274b8db6e4d82bce861bbb22e6dbed40417902c65"
"checksum trust-dns-proto 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)" = "f1525ca4e26f5a09d81b79584f19225e7dba5606ae3a416311c2751c5cea60bb"
"checksum trust-dns-resolver 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)" = "4a821ad51a29816420b8cac4b026756b81c023630b97eaa4c8090637ee3508bd"

[3.146011]

[3.148800]

"checksum tokio-current-thread 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)" = "d16217cad7f1b840c5a97dfb3c43b0c871fef423a6e8d2118c604e843662a443"
"checksum tokio-executor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)" = "83ea44c6c0773cc034771693711c35c677b4b5a4b21b9e7071704c54de7d555e"
"checksum tokio-fs 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)" = "3fe6dc22b08d6993916647d108a1a7d15b9cd29c4f4496c62b92c45b5041b7af"
"checksum tokio-io 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)" = "5090db468dad16e1a7a54c8c67280c5e4b544f3d3e018f0b913b400261f85926"
"checksum tokio-reactor 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)" = "6af16bfac7e112bea8b0442542161bfc41cbfa4466b580bdda7d18cb88b911ce"
"checksum tokio-signal 0.2.7 (registry+https://github.com/rust-lang/crates.io-index)" = "dd6dc5276ea05ce379a16de90083ec80836440d5ef8a6a39545a3207373b8296"
"checksum tokio-sync 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)" = "fda385df506bf7546e70872767f71e81640f1f251bdf2fd8eb81a0eaec5fe022"
"checksum tokio-tcp 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "1d14b10654be682ac43efee27401d792507e30fd8d26389e1da3b185de2e4119"
"checksum tokio-threadpool 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)" = "ec5759cf26cf9659555f36c431b515e3d05f66831741c85b4b5d5dfb9cf1323c"
"checksum tokio-timer 0.2.10 (registry+https://github.com/rust-lang/crates.io-index)" = "2910970404ba6fa78c5539126a9ae2045d62e3713041e447f695f41405a120c6"
"checksum tokio-tls 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "354b8cd83825b3c20217a9dc174d6a0c67441a2fae5c41bcb1ea6679f6ae0f7c"
"checksum tokio-trace-core 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "350c9edade9830dc185ae48ba45667a445ab59f6167ef6d0254ec9d2430d9dd3"
"checksum tokio-udp 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "66268575b80f4a4a710ef83d087fdfeeabdce9b74c797535fbac18a2cb906e92"
"checksum tokio-uds 0.2.5 (registry+https://github.com/rust-lang/crates.io-index)" = "037ffc3ba0e12a0ab4aca92e5234e0dedeb48fddf6ccd260f1f150a36a9f2445"
"checksum tokio-xmpp 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "952074d50e2a9907e714d28bb988232cc2f8c64542d3a97822e6d6afdd7a105f"
"checksum toml 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)" = "87c5890a989fa47ecdc7bcb4c63a77a82c18f306714104b1decfd722db17b39e"
"checksum trust-dns-proto 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)" = "09144f0992b0870fa8d2972cc069cbf1e3c0fda64d1f3d45c4d68d0e0b52ad4e"
"checksum trust-dns-resolver 0.10.3 (registry+https://github.com/rust-lang/crates.io-index)" = "8a9f877f7a1ad821ab350505e1f1b146a4960402991787191d6d8cab2ce2de2c"
replacement in Cargo.lock at line 2085

[3.148951]→[2.93988:94139](∅→∅)

"checksum try_from 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "923a7ee3e97dbfe8685261beb4511cc9620a1252405d02693d43169729570111"

[3.148951]

[3.149102]

"checksum try_from 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)" = "283d3b89e1368717881a9d51dad843cc435380d8109c9e47d38780a324698d8b"
replacement in Cargo.lock at line 2087

[3.149253]→[2.94140:94291](∅→∅)

"checksum ucd-util 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "fd2be2d6639d0f8fe6cdda291ad456e23629558d466e2789d2c3e9892bda285d"

[3.149253]

[3.149404]

"checksum ucd-util 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "535c204ee4d8434478593480b8f86ab45ec9aae0e83c568ca81abf0fd0e88f86"
replacement in Cargo.lock at line 2089

[3.149559]→[2.94292:94456](∅→∅)

"checksum unicode-normalization 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)" = "6a0180bc61fc5a987082bfa111f4cc95c4caff7f9799f3e46df09163a937aa25"

[3.149559]

[3.149723]

"checksum unicode-normalization 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)" = "141339a08b982d942be2ca06ff8b076563cbe223d1befd5450716790d44e2426"
replacement in Cargo.lock at line 2093

[3.150187]→[2.94457:95059](∅→∅)

"checksum unreachable 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "382810877fe448991dfc7f0dd6e3ae5d58088fd0ea5e35189655f84e6814fa56"
"checksum url 1.7.1 (registry+https://github.com/rust-lang/crates.io-index)" = "2a321979c09843d272956e73700d12c4e7d3d92b2ee112b31548aef0d4efc5a6"
"checksum utf-8 0.7.4 (registry+https://github.com/rust-lang/crates.io-index)" = "bab35f71693630bb1953dce0f2bcd780e7cde025027124a202ac08a45ba25141"
"checksum utf8-ranges 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)" = "fd70f467df6810094968e2fce0ee1bd0e87157aceb026a8c083bcf5e25b9efe4"

[3.150187]

[3.150635]

"checksum url 1.7.2 (registry+https://github.com/rust-lang/crates.io-index)" = "dd4e7c0d531266369519a4aa4f399d748bd37043b00bde1e4ff1f60a120b355a"
"checksum utf-8 0.7.5 (registry+https://github.com/rust-lang/crates.io-index)" = "05e42f7c18b8f902290b009cde6d651262f956c98bc51bca4cd1d511c9cd85c7"
"checksum utf8-ranges 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)" = "796f7e48bef87609f7ade7e06495a87d5cd06c7866e6a5cbfceffc558a243737"
edit in Cargo.lock at line 2098

[3.150933]→[2.95060:95363](∅→∅)

"checksum version_check 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "914b1a6776c4c929a602fafd8bc742e06365d4bcbe48c30f9cca5824f70dc9dd"
"checksum void 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)" = "6a02e4885ed3bc0f2de90ea6dd45ebcbb66dacffe03547fadbb0eeae2770887d"
replacement in Cargo.lock at line 2101

[3.151382]→[2.95364:95513](∅→∅)

"checksum winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)" = "92c1eb33641e276cfa214a0522acad57be5c56b10cb348b3c5117db75f3ac4b0"

[3.151382]

[3.151531]

"checksum winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)" = "f10e386af2b13e47c89e7236a7a14a086791a2b88ebad6df9bf42040195cf770"
replacement in Cargo.lock at line 2104

[3.151855]→[2.95514:95668](∅→∅)

"checksum winapi-util 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "afc5508759c5bf4285e61feb862b6083c8480aec864fa17a81fdec6f69b461ab"

[3.151855]

[3.152009]

"checksum winapi-util 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "7168bab6e1daee33b4557efd0e95d5ca70a03706d39fa5f3fe7a236f584b03c9"
replacement in Cargo.lock at line 2110

[3.152783]→[2.95669:95977](∅→∅)

"checksum xml5ever 0.12.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ead952cf8bab253fb5cb56e1fff780747bbf7a7258fb0451afe645a166050b1f"
"checksum xmpp-parsers 0.11.1 (registry+https://github.com/rust-lang/crates.io-index)" = "2e1e0a279d5af83a1dff442249f8a43214ac120267acfaac494b9d28c0027fea"

[3.152783]

"checksum xml5ever 0.12.1 (registry+https://github.com/rust-lang/crates.io-index)" = "32cd7ebf0203c620906230ce22caa5df0b603c32b6fef72a275a48f6a2ae64b9"
"checksum xmpp-parsers 0.12.2 (registry+https://github.com/rust-lang/crates.io-index)" = "58b4400e1ae0d246044db5fa7f2e693fdfe9cc6e8eaa72ef2a68c5dc1d3c96de"
"checksum xmpp-parsers 0.13.1 (registry+https://github.com/rust-lang/crates.io-index)" = "5094cec449beca92f82ae4d7fe13cda058005849766d71b86c23e6217f61a357"