1// Copyright (c) 2019 Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
2//
3// This Source Code Form is subject to the terms of the Mozilla Public
4// License, v. 2.0. If a copy of the MPL was not distributed with this
5// file, You can obtain one at http://mozilla.org/MPL/2.0/.
6
7#![deny(bare_trait_objects)]
8
9use futures::stream::StreamExt;
10use reqwest::{
11 header::HeaderMap as ReqwestHeaderMap, Body as ReqwestBody, Client as ReqwestClient,
12};
13use std::convert::TryFrom;
14use std::path::{Path, PathBuf};
15use std::sync::{Arc, RwLock};
16use tokio::fs::File;
17use tokio_util::codec::{BytesCodec, FramedRead};
18use tokio_xmpp::{AsyncClient as TokioXmppClient, Event as TokioXmppEvent};
19use xmpp_parsers::{
20 bookmarks2::Conference,
21 caps::{compute_disco, hash_caps, Caps},
22 disco::{DiscoInfoQuery, DiscoInfoResult, Feature, Identity},
23 hashes::Algo,
24 http_upload::{Header as HttpUploadHeader, SlotRequest, SlotResult},
25 iq::{Iq, IqType},
26 message::{Body, Message, MessageType},
27 muc::{
28 user::{MucUser, Status},
29 Muc,
30 },
31 ns,
32 presence::{Presence, Type as PresenceType},
33 pubsub::pubsub::{Items, PubSub},
34 roster::{Item as RosterItem, Roster},
35 stanza_error::{DefinedCondition, ErrorType, StanzaError},
36 BareJid, Element, Jid,
37};
38#[macro_use]
39extern crate log;
40
41mod pubsub;
42
43pub type Error = tokio_xmpp::Error;
44
45#[derive(Debug)]
46pub enum ClientType {
47 Bot,
48 Pc,
49}
50
51impl Default for ClientType {
52 fn default() -> Self {
53 ClientType::Bot
54 }
55}
56
57impl ToString for ClientType {
58 fn to_string(&self) -> String {
59 String::from(match self {
60 ClientType::Bot => "bot",
61 ClientType::Pc => "pc",
62 })
63 }
64}
65
66#[derive(PartialEq)]
67pub enum ClientFeature {
68 #[cfg(feature = "avatars")]
69 Avatars,
70 ContactList,
71 JoinRooms,
72}
73
74pub type Id = Option<String>;
75pub type RoomNick = String;
76
77#[derive(Debug)]
78pub enum Event {
79 Online,
80 Disconnected,
81 ContactAdded(RosterItem),
82 ContactRemoved(RosterItem),
83 ContactChanged(RosterItem),
84 #[cfg(feature = "avatars")]
85 AvatarRetrieved(Jid, String),
86 ChatMessage(Id, BareJid, Body),
87 JoinRoom(BareJid, Conference),
88 LeaveRoom(BareJid),
89 LeaveAllRooms,
90 RoomJoined(BareJid),
91 RoomLeft(BareJid),
92 RoomMessage(Id, BareJid, RoomNick, Body),
93 /// A private message received from a room, containing the message ID, the room's BareJid,
94 /// the sender's nickname, and the message body.
95 RoomPrivateMessage(Id, BareJid, RoomNick, Body),
96 ServiceMessage(Id, BareJid, Body),
97 HttpUploadedFile(String),
98}
99
100pub struct ClientBuilder<'a> {
101 jid: BareJid,
102 password: &'a str,
103 website: String,
104 default_nick: String,
105 lang: Vec<String>,
106 disco: (ClientType, String),
107 features: Vec<ClientFeature>,
108 resource: Option<String>,
109}
110
111impl ClientBuilder<'_> {
112 pub fn new<'a>(jid: BareJid, password: &'a str) -> ClientBuilder<'a> {
113 ClientBuilder {
114 jid,
115 password,
116 website: String::from("https://gitlab.com/xmpp-rs/tokio-xmpp"),
117 default_nick: String::from("xmpp-rs"),
118 lang: vec![String::from("en")],
119 disco: (ClientType::default(), String::from("tokio-xmpp")),
120 features: vec![],
121 resource: None,
122 }
123 }
124
125 /// Optionally set a resource associated to this device on the client
126 pub fn set_resource(mut self, resource: &str) -> Self {
127 self.resource = Some(resource.to_string());
128 self
129 }
130
131 pub fn set_client(mut self, type_: ClientType, name: &str) -> Self {
132 self.disco = (type_, String::from(name));
133 self
134 }
135
136 pub fn set_website(mut self, url: &str) -> Self {
137 self.website = String::from(url);
138 self
139 }
140
141 pub fn set_default_nick(mut self, nick: &str) -> Self {
142 self.default_nick = String::from(nick);
143 self
144 }
145
146 pub fn set_lang(mut self, lang: Vec<String>) -> Self {
147 self.lang = lang;
148 self
149 }
150
151 pub fn enable_feature(mut self, feature: ClientFeature) -> Self {
152 self.features.push(feature);
153 self
154 }
155
156 fn make_disco(&self) -> DiscoInfoResult {
157 let identities = vec![Identity::new(
158 "client",
159 self.disco.0.to_string(),
160 "en",
161 self.disco.1.to_string(),
162 )];
163 let mut features = vec![Feature::new(ns::DISCO_INFO)];
164 #[cfg(feature = "avatars")]
165 {
166 if self.features.contains(&ClientFeature::Avatars) {
167 features.push(Feature::new(format!("{}+notify", ns::AVATAR_METADATA)));
168 }
169 }
170 if self.features.contains(&ClientFeature::JoinRooms) {
171 features.push(Feature::new(format!("{}+notify", ns::BOOKMARKS2)));
172 }
173 DiscoInfoResult {
174 node: None,
175 identities,
176 features,
177 extensions: vec![],
178 }
179 }
180
181 pub fn build(self) -> Agent {
182 let jid: Jid = if let Some(resource) = &self.resource {
183 self.jid.with_resource_str(resource).unwrap().into()
184 } else {
185 self.jid.clone().into()
186 };
187
188 let client = TokioXmppClient::new(jid, self.password);
189 self.build_impl(client)
190 }
191
192 // This function is meant to be used for testing build
193 pub(crate) fn build_impl(self, client: TokioXmppClient) -> Agent {
194 let disco = self.make_disco();
195 let node = self.website;
196
197 Agent {
198 client,
199 default_nick: Arc::new(RwLock::new(self.default_nick)),
200 lang: Arc::new(self.lang),
201 disco,
202 node,
203 uploads: Vec::new(),
204 }
205 }
206}
207
208pub struct Agent {
209 client: TokioXmppClient,
210 default_nick: Arc<RwLock<String>>,
211 lang: Arc<Vec<String>>,
212 disco: DiscoInfoResult,
213 node: String,
214 uploads: Vec<(String, Jid, PathBuf)>,
215}
216
217impl Agent {
218 pub async fn disconnect(&mut self) -> Result<(), Error> {
219 self.client.send_end().await
220 }
221
222 pub async fn join_room(
223 &mut self,
224 room: BareJid,
225 nick: Option<String>,
226 password: Option<String>,
227 lang: &str,
228 status: &str,
229 ) {
230 let mut muc = Muc::new();
231 if let Some(password) = password {
232 muc = muc.with_password(password);
233 }
234
235 let nick = nick.unwrap_or_else(|| self.default_nick.read().unwrap().clone());
236 let room_jid = room.with_resource_str(&nick).unwrap();
237 let mut presence = Presence::new(PresenceType::None).with_to(room_jid);
238 presence.add_payload(muc);
239 presence.set_status(String::from(lang), String::from(status));
240 let _ = self.client.send_stanza(presence.into()).await;
241 }
242
243 pub async fn send_message(
244 &mut self,
245 recipient: Jid,
246 type_: MessageType,
247 lang: &str,
248 text: &str,
249 ) {
250 let mut message = Message::new(Some(recipient));
251 message.type_ = type_;
252 message
253 .bodies
254 .insert(String::from(lang), Body(String::from(text)));
255 let _ = self.client.send_stanza(message.into()).await;
256 }
257
258 pub async fn send_room_private_message(
259 &mut self,
260 room: BareJid,
261 recipient: RoomNick,
262 lang: &str,
263 text: &str,
264 ) {
265 let recipient: Jid = room.with_resource_str(&recipient).unwrap().into();
266 let mut message = Message::new(recipient).with_payload(MucUser::new());
267 message.type_ = MessageType::Chat;
268 message
269 .bodies
270 .insert(String::from(lang), Body(String::from(text)));
271 let _ = self.client.send_stanza(message.into()).await;
272 }
273
274 fn make_initial_presence(disco: &DiscoInfoResult, node: &str) -> Presence {
275 let caps_data = compute_disco(disco);
276 let hash = hash_caps(&caps_data, Algo::Sha_1).unwrap();
277 let caps = Caps::new(node, hash);
278
279 let mut presence = Presence::new(PresenceType::None);
280 presence.add_payload(caps);
281 presence
282 }
283
284 async fn handle_iq(&mut self, iq: Iq) -> Vec<Event> {
285 let mut events = vec![];
286 let from = iq
287 .from
288 .clone()
289 .unwrap_or_else(|| self.client.bound_jid().unwrap().clone());
290 if let IqType::Get(payload) = iq.payload {
291 if payload.is("query", ns::DISCO_INFO) {
292 let query = DiscoInfoQuery::try_from(payload);
293 match query {
294 Ok(query) => {
295 let mut disco_info = self.disco.clone();
296 disco_info.node = query.node;
297 let iq = Iq::from_result(iq.id, Some(disco_info))
298 .with_to(iq.from.unwrap())
299 .into();
300 let _ = self.client.send_stanza(iq).await;
301 }
302 Err(err) => {
303 let error = StanzaError::new(
304 ErrorType::Modify,
305 DefinedCondition::BadRequest,
306 "en",
307 &format!("{}", err),
308 );
309 let iq = Iq::from_error(iq.id, error)
310 .with_to(iq.from.unwrap())
311 .into();
312 let _ = self.client.send_stanza(iq).await;
313 }
314 }
315 } else {
316 // We MUST answer unhandled get iqs with a service-unavailable error.
317 let error = StanzaError::new(
318 ErrorType::Cancel,
319 DefinedCondition::ServiceUnavailable,
320 "en",
321 "No handler defined for this kind of iq.",
322 );
323 let iq = Iq::from_error(iq.id, error)
324 .with_to(iq.from.unwrap())
325 .into();
326 let _ = self.client.send_stanza(iq).await;
327 }
328 } else if let IqType::Result(Some(payload)) = iq.payload {
329 // TODO: move private iqs like this one somewhere else, for
330 // security reasons.
331 if payload.is("query", ns::ROSTER) && Some(from.clone()) == iq.from {
332 let roster = Roster::try_from(payload).unwrap();
333 for item in roster.items.into_iter() {
334 events.push(Event::ContactAdded(item));
335 }
336 } else if payload.is("pubsub", ns::PUBSUB) {
337 let new_events = pubsub::handle_iq_result(&from, payload);
338 events.extend(new_events);
339 } else if payload.is("slot", ns::HTTP_UPLOAD) {
340 let new_events = handle_upload_result(&from, iq.id, payload, self).await;
341 events.extend(new_events);
342 }
343 } else if let IqType::Set(_) = iq.payload {
344 // We MUST answer unhandled set iqs with a service-unavailable error.
345 let error = StanzaError::new(
346 ErrorType::Cancel,
347 DefinedCondition::ServiceUnavailable,
348 "en",
349 "No handler defined for this kind of iq.",
350 );
351 let iq = Iq::from_error(iq.id, error)
352 .with_to(iq.from.unwrap())
353 .into();
354 let _ = self.client.send_stanza(iq).await;
355 }
356
357 events
358 }
359
360 async fn handle_message(&mut self, message: Message) -> Vec<Event> {
361 let mut events = vec![];
362 let from = message.from.clone().unwrap();
363 let langs: Vec<&str> = self.lang.iter().map(String::as_str).collect();
364 match message.get_best_body(langs) {
365 Some((_lang, body)) => match message.type_ {
366 MessageType::Groupchat => {
367 let event = match from.clone() {
368 Jid::Full(full) => Event::RoomMessage(
369 message.id.clone(),
370 from.to_bare(),
371 full.resource_str().to_owned(),
372 body.clone(),
373 ),
374 Jid::Bare(bare) => {
375 Event::ServiceMessage(message.id.clone(), bare, body.clone())
376 }
377 };
378 events.push(event)
379 }
380 MessageType::Chat | MessageType::Normal => {
381 let mut found_special_message = false;
382
383 for payload in &message.payloads {
384 if let Ok(_) = MucUser::try_from(payload.clone()) {
385 let event = match from.clone() {
386 Jid::Bare(bare) => {
387 // TODO: Can a service message be of type Chat/Normal and not Groupchat?
388 warn!("Received misformed MessageType::Chat in muc#user namespace from a bare JID.");
389 Event::ServiceMessage(message.id.clone(), bare, body.clone())
390 }
391 Jid::Full(full) => Event::RoomPrivateMessage(
392 message.id.clone(),
393 full.to_bare(),
394 full.resource_str().to_owned(),
395 body.clone(),
396 ),
397 };
398
399 found_special_message = true;
400 events.push(event);
401 }
402 }
403
404 if !found_special_message {
405 let event =
406 Event::ChatMessage(message.id.clone(), from.to_bare(), body.clone());
407 events.push(event)
408 }
409 }
410 _ => (),
411 },
412 None => (),
413 }
414 for child in message.payloads {
415 if child.is("event", ns::PUBSUB_EVENT) {
416 let new_events = pubsub::handle_event(&from, child, self).await;
417 events.extend(new_events);
418 }
419 }
420
421 events
422 }
423
424 async fn handle_presence(&mut self, presence: Presence) -> Vec<Event> {
425 let mut events = vec![];
426 let from = presence.from.unwrap().to_bare();
427 for payload in presence.payloads.into_iter() {
428 let muc_user = match MucUser::try_from(payload) {
429 Ok(muc_user) => muc_user,
430 _ => continue,
431 };
432 for status in muc_user.status.into_iter() {
433 if status == Status::SelfPresence {
434 events.push(Event::RoomJoined(from.clone()));
435 break;
436 }
437 }
438 }
439
440 events
441 }
442
443 pub async fn wait_for_events(&mut self) -> Option<Vec<Event>> {
444 if let Some(event) = self.client.next().await {
445 let mut events = Vec::new();
446
447 match event {
448 TokioXmppEvent::Online { resumed: false, .. } => {
449 let presence = Self::make_initial_presence(&self.disco, &self.node).into();
450 let _ = self.client.send_stanza(presence).await;
451 events.push(Event::Online);
452 // TODO: only send this when the ContactList feature is enabled.
453 let iq = Iq::from_get(
454 "roster",
455 Roster {
456 ver: None,
457 items: vec![],
458 },
459 )
460 .into();
461 let _ = self.client.send_stanza(iq).await;
462 // TODO: only send this when the JoinRooms feature is enabled.
463 let iq =
464 Iq::from_get("bookmarks", PubSub::Items(Items::new(ns::BOOKMARKS2))).into();
465 let _ = self.client.send_stanza(iq).await;
466 }
467 TokioXmppEvent::Online { resumed: true, .. } => {}
468 TokioXmppEvent::Disconnected(_) => {
469 events.push(Event::Disconnected);
470 }
471 TokioXmppEvent::Stanza(elem) => {
472 if elem.is("iq", "jabber:client") {
473 let iq = Iq::try_from(elem).unwrap();
474 let new_events = self.handle_iq(iq).await;
475 events.extend(new_events);
476 } else if elem.is("message", "jabber:client") {
477 let message = Message::try_from(elem).unwrap();
478 let new_events = self.handle_message(message).await;
479 events.extend(new_events);
480 } else if elem.is("presence", "jabber:client") {
481 let presence = Presence::try_from(elem).unwrap();
482 let new_events = self.handle_presence(presence).await;
483 events.extend(new_events);
484 } else if elem.is("error", "http://etherx.jabber.org/streams") {
485 println!("Received a fatal stream error: {}", String::from(&elem));
486 } else {
487 panic!("Unknown stanza: {}", String::from(&elem));
488 }
489 }
490 }
491
492 Some(events)
493 } else {
494 None
495 }
496 }
497
498 pub async fn upload_file_with(&mut self, service: &str, path: &Path) {
499 let name = path.file_name().unwrap().to_str().unwrap().to_string();
500 let file = File::open(path).await.unwrap();
501 let size = file.metadata().await.unwrap().len();
502 let slot_request = SlotRequest {
503 filename: name,
504 size: size,
505 content_type: None,
506 };
507 let to = service.parse::<Jid>().unwrap();
508 let request = Iq::from_get("upload1", slot_request).with_to(to.clone());
509 self.uploads
510 .push((String::from("upload1"), to, path.to_path_buf()));
511 self.client.send_stanza(request.into()).await.unwrap();
512 }
513}
514
515async fn handle_upload_result(
516 from: &Jid,
517 iqid: String,
518 elem: Element,
519 agent: &mut Agent,
520) -> impl IntoIterator<Item = Event> {
521 let mut res: Option<(usize, PathBuf)> = None;
522
523 for (i, (id, to, filepath)) in agent.uploads.iter().enumerate() {
524 if to == from && id == &iqid {
525 res = Some((i, filepath.to_path_buf()));
526 break;
527 }
528 }
529
530 if let Some((index, file)) = res {
531 agent.uploads.remove(index);
532 let slot = SlotResult::try_from(elem).unwrap();
533
534 let mut headers = ReqwestHeaderMap::new();
535 for header in slot.put.headers {
536 let (attr, val) = match header {
537 HttpUploadHeader::Authorization(val) => ("Authorization", val),
538 HttpUploadHeader::Cookie(val) => ("Cookie", val),
539 HttpUploadHeader::Expires(val) => ("Expires", val),
540 };
541 headers.insert(attr, val.parse().unwrap());
542 }
543
544 let web = ReqwestClient::new();
545 let stream = FramedRead::new(File::open(file).await.unwrap(), BytesCodec::new());
546 let body = ReqwestBody::wrap_stream(stream);
547 let res = web
548 .put(slot.put.url.as_str())
549 .headers(headers)
550 .body(body)
551 .send()
552 .await
553 .unwrap();
554 if res.status() == 201 {
555 return vec![Event::HttpUploadedFile(slot.get.url)];
556 }
557 }
558
559 return vec![];
560}
561
562#[cfg(test)]
563mod tests {
564 use super::{Agent, BareJid, ClientBuilder, ClientFeature, ClientType, Event};
565 use std::str::FromStr;
566 use tokio_xmpp::AsyncClient as TokioXmppClient;
567
568 #[tokio::test]
569 async fn test_simple() {
570 let jid = BareJid::from_str("foo@bar").unwrap();
571
572 let client = TokioXmppClient::new(jid.clone(), "meh");
573
574 // Client instance
575 let client_builder = ClientBuilder::new(jid, "meh")
576 .set_client(ClientType::Bot, "xmpp-rs")
577 .set_website("https://gitlab.com/xmpp-rs/xmpp-rs")
578 .set_default_nick("bot")
579 .enable_feature(ClientFeature::ContactList);
580
581 #[cfg(feature = "avatars")]
582 let client_builder = client_builder.enable_feature(ClientFeature::Avatars);
583
584 let mut agent: Agent = client_builder.build_impl(client);
585
586 while let Some(events) = agent.wait_for_events().await {
587 assert!(match events[0] {
588 Event::Disconnected => true,
589 _ => false,
590 });
591 assert_eq!(events.len(), 1);
592 break;
593 }
594 }
595}