1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
use std::time::Duration;
use bytes::Bytes;
use ricq_core::command::config_push_svc::ConfigPushBody;
use ricq_core::command::config_push_svc::ConfigPushReq;
use ricq_core::common::RQAddr;
use crate::client::tcp::sort_addrs;
use crate::client::Client;
use crate::RQError;
impl Client {
pub(crate) async fn process_config_push_req(
&self,
config_push_req: ConfigPushReq,
) -> Result<(), RQError> {
let resp = config_push_req.resp;
let response = self.engine.read().await.build_conf_push_resp_packet(
resp.t,
resp.pkt_seq,
resp.jce_buf,
);
self.send(response).await?;
match config_push_req.body {
ConfigPushBody::Unknown => {}
ConfigPushBody::SsoServers { .. } => {}
ConfigPushBody::FileStorageInfo { info: _, rsp_body } => {
let mut session = self.highway_session.write().await;
if let Some(rsp_body) = rsp_body {
session.sig_session = Bytes::from(rsp_body.sig_session.unwrap_or_default());
session.session_key = Bytes::from(rsp_body.session_key.unwrap_or_default());
session.uin = self.uin().await;
session.app_id = self.engine.read().await.transport.version.app_id as i32;
for addr in rsp_body.addrs.into_iter() {
let service_type = addr.service_type.unwrap_or_default();
if service_type == 10 {
let addrs: Vec<RQAddr> = addr
.addrs
.into_iter()
.map(|addr| {
RQAddr(
addr.ip.unwrap_or_default(),
addr.port.unwrap_or_default() as u16,
)
})
.collect();
self.highway_addrs.write().await.extend(addrs);
{
let mut addrs = self.highway_addrs.read().await.clone();
addrs.dedup_by(|a, b| (a.0 == b.0 && a.1 == b.1));
let sorted_addrs = sort_addrs(addrs, Duration::from_secs(5)).await;
let mut highway_addrs = self.highway_addrs.write().await;
highway_addrs.clear();
highway_addrs.extend(sorted_addrs);
}
} else if service_type == 11 {
}
}
}
}
}
Ok(())
}
}