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, FullJid, 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.clone().with_resource(resource.to_string()).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(nick);
237 let mut presence = Presence::new(PresenceType::None).with_to(Jid::Full(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(recipient).into();
266 let mut message = Message::new(Some(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.clone().into(),
371 full.resource,
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.clone().into(),
394 full.resource,
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 = Event::ChatMessage(
406 message.id.clone(),
407 from.clone().into(),
408 body.clone(),
409 );
410 events.push(event)
411 }
412 }
413 _ => (),
414 },
415 None => (),
416 }
417 for child in message.payloads {
418 if child.is("event", ns::PUBSUB_EVENT) {
419 let new_events = pubsub::handle_event(&from, child, self).await;
420 events.extend(new_events);
421 }
422 }
423
424 events
425 }
426
427 async fn handle_presence(&mut self, presence: Presence) -> Vec<Event> {
428 let mut events = vec![];
429 let from: BareJid = match presence.from.clone().unwrap() {
430 Jid::Full(FullJid { node, domain, .. }) => BareJid { node, domain },
431 Jid::Bare(bare) => bare,
432 };
433 for payload in presence.payloads.into_iter() {
434 let muc_user = match MucUser::try_from(payload) {
435 Ok(muc_user) => muc_user,
436 _ => continue,
437 };
438 for status in muc_user.status.into_iter() {
439 if status == Status::SelfPresence {
440 events.push(Event::RoomJoined(from.clone()));
441 break;
442 }
443 }
444 }
445
446 events
447 }
448
449 pub async fn wait_for_events(&mut self) -> Option<Vec<Event>> {
450 if let Some(event) = self.client.next().await {
451 let mut events = Vec::new();
452
453 match event {
454 TokioXmppEvent::Online { resumed: false, .. } => {
455 let presence = Self::make_initial_presence(&self.disco, &self.node).into();
456 let _ = self.client.send_stanza(presence).await;
457 events.push(Event::Online);
458 // TODO: only send this when the ContactList feature is enabled.
459 let iq = Iq::from_get(
460 "roster",
461 Roster {
462 ver: None,
463 items: vec![],
464 },
465 )
466 .into();
467 let _ = self.client.send_stanza(iq).await;
468 // TODO: only send this when the JoinRooms feature is enabled.
469 let iq =
470 Iq::from_get("bookmarks", PubSub::Items(Items::new(ns::BOOKMARKS2))).into();
471 let _ = self.client.send_stanza(iq).await;
472 }
473 TokioXmppEvent::Online { resumed: true, .. } => {}
474 TokioXmppEvent::Disconnected(_) => {
475 events.push(Event::Disconnected);
476 }
477 TokioXmppEvent::Stanza(elem) => {
478 if elem.is("iq", "jabber:client") {
479 let iq = Iq::try_from(elem).unwrap();
480 let new_events = self.handle_iq(iq).await;
481 events.extend(new_events);
482 } else if elem.is("message", "jabber:client") {
483 let message = Message::try_from(elem).unwrap();
484 let new_events = self.handle_message(message).await;
485 events.extend(new_events);
486 } else if elem.is("presence", "jabber:client") {
487 let presence = Presence::try_from(elem).unwrap();
488 let new_events = self.handle_presence(presence).await;
489 events.extend(new_events);
490 } else if elem.is("error", "http://etherx.jabber.org/streams") {
491 println!("Received a fatal stream error: {}", String::from(&elem));
492 } else {
493 panic!("Unknown stanza: {}", String::from(&elem));
494 }
495 }
496 }
497
498 Some(events)
499 } else {
500 None
501 }
502 }
503
504 pub async fn upload_file_with(&mut self, service: &str, path: &Path) {
505 let name = path.file_name().unwrap().to_str().unwrap().to_string();
506 let file = File::open(path).await.unwrap();
507 let size = file.metadata().await.unwrap().len();
508 let slot_request = SlotRequest {
509 filename: name,
510 size: size,
511 content_type: None,
512 };
513 let to = service.parse::<Jid>().unwrap();
514 let request = Iq::from_get("upload1", slot_request).with_to(to.clone());
515 self.uploads
516 .push((String::from("upload1"), to, path.to_path_buf()));
517 self.client.send_stanza(request.into()).await.unwrap();
518 }
519}
520
521async fn handle_upload_result(
522 from: &Jid,
523 iqid: String,
524 elem: Element,
525 agent: &mut Agent,
526) -> impl IntoIterator<Item = Event> {
527 let mut res: Option<(usize, PathBuf)> = None;
528
529 for (i, (id, to, filepath)) in agent.uploads.iter().enumerate() {
530 if to == from && id == &iqid {
531 res = Some((i, filepath.to_path_buf()));
532 break;
533 }
534 }
535
536 if let Some((index, file)) = res {
537 agent.uploads.remove(index);
538 let slot = SlotResult::try_from(elem).unwrap();
539
540 let mut headers = ReqwestHeaderMap::new();
541 for header in slot.put.headers {
542 let (attr, val) = match header {
543 HttpUploadHeader::Authorization(val) => ("Authorization", val),
544 HttpUploadHeader::Cookie(val) => ("Cookie", val),
545 HttpUploadHeader::Expires(val) => ("Expires", val),
546 };
547 headers.insert(attr, val.parse().unwrap());
548 }
549
550 let web = ReqwestClient::new();
551 let stream = FramedRead::new(File::open(file).await.unwrap(), BytesCodec::new());
552 let body = ReqwestBody::wrap_stream(stream);
553 let res = web
554 .put(slot.put.url.as_str())
555 .headers(headers)
556 .body(body)
557 .send()
558 .await
559 .unwrap();
560 if res.status() == 201 {
561 return vec![Event::HttpUploadedFile(slot.get.url)];
562 }
563 }
564
565 return vec![];
566}
567
568#[cfg(test)]
569mod tests {
570 use super::{Agent, BareJid, ClientBuilder, ClientFeature, ClientType, Event};
571 use std::str::FromStr;
572 use tokio_xmpp::AsyncClient as TokioXmppClient;
573
574 #[tokio::test]
575 async fn test_simple() {
576 let jid = BareJid::from_str("foo@bar").unwrap();
577
578 let client = TokioXmppClient::new(jid.clone(), "meh");
579
580 // Client instance
581 let client_builder = ClientBuilder::new(jid, "meh")
582 .set_client(ClientType::Bot, "xmpp-rs")
583 .set_website("https://gitlab.com/xmpp-rs/xmpp-rs")
584 .set_default_nick("bot")
585 .enable_feature(ClientFeature::Avatars)
586 .enable_feature(ClientFeature::ContactList);
587
588 let mut agent: Agent = client_builder.build_impl(client);
589
590 while let Some(events) = agent.wait_for_events().await {
591 assert!(match events[0] {
592 Event::Disconnected => true,
593 _ => false,
594 });
595 assert_eq!(events.len(), 1);
596 break;
597 }
598 }
599}