xmpp_component.cpp 22.1 KB
Newer Older
1
#include <utils/make_unique.hpp>
2
#include <utils/scopeguard.hpp>
louiz’'s avatar
louiz’ committed
3
#include <logger/logger.hpp>
4

5
#include <xmpp/xmpp_component.hpp>
6
#include <xmpp/jid.hpp>
7

8
9
#include <utils/sha1.hpp>

louiz’'s avatar
louiz’ committed
10
#include <stdexcept>
11
12
#include <iostream>

13
#include <stdio.h>
14

15
16
17
18
#define STREAM_NS        "http://etherx.jabber.org/streams"
#define COMPONENT_NS     "jabber:component:accept"
#define MUC_NS           "http://jabber.org/protocol/muc"
#define MUC_USER_NS      MUC_NS"#user"
19
#define MUC_ADMIN_NS     MUC_NS"#admin"
20
21
22
#define DISCO_NS         "http://jabber.org/protocol/disco"
#define DISCO_ITEMS_NS   DISCO_NS"#items"
#define DISCO_INFO_NS    DISCO_NS"#info"
23
#define XHTMLIM_NS       "http://jabber.org/protocol/xhtml-im"
24
#define STANZA_NS        "urn:ietf:params:xml:ns:xmpp-stanzas"
louiz’'s avatar
louiz’ committed
25
#define STREAMS_NS       "urn:ietf:params:xml:ns:xmpp-streams"
26

27
XmppComponent::XmppComponent(const std::string& hostname, const std::string& secret):
28
29
  ever_auth(false),
  last_auth(false),
30
31
  served_hostname(hostname),
  secret(secret),
louiz’'s avatar
louiz’ committed
32
33
  authenticated(false),
  doc_open(false)
34
35
36
37
38
39
40
{
  this->parser.add_stream_open_callback(std::bind(&XmppComponent::on_remote_stream_open, this,
                                                  std::placeholders::_1));
  this->parser.add_stanza_callback(std::bind(&XmppComponent::on_stanza, this,
                                                  std::placeholders::_1));
  this->parser.add_stream_close_callback(std::bind(&XmppComponent::on_remote_stream_close, this,
                                                  std::placeholders::_1));
41
  this->stanza_handlers.emplace(COMPONENT_NS":handshake",
42
                                std::bind(&XmppComponent::handle_handshake, this,std::placeholders::_1));
43
  this->stanza_handlers.emplace(COMPONENT_NS":presence",
44
                                std::bind(&XmppComponent::handle_presence, this,std::placeholders::_1));
45
  this->stanza_handlers.emplace(COMPONENT_NS":message",
louiz’'s avatar
louiz’ committed
46
                                std::bind(&XmppComponent::handle_message, this,std::placeholders::_1));
47
48
  this->stanza_handlers.emplace(COMPONENT_NS":iq",
                                std::bind(&XmppComponent::handle_iq, this,std::placeholders::_1));
louiz’'s avatar
louiz’ committed
49
50
  this->stanza_handlers.emplace(STREAM_NS":error",
                                std::bind(&XmppComponent::handle_error, this,std::placeholders::_1));
51
52
53
54
55
56
}

XmppComponent::~XmppComponent()
{
}

57
void XmppComponent::start()
58
{
59
  this->connect("127.0.0.1", "5347");
60
61
}

louiz’'s avatar
louiz’ committed
62
63
64
65
66
bool XmppComponent::is_document_open() const
{
  return this->doc_open;
}

67
68
void XmppComponent::send_stanza(const Stanza& stanza)
{
louiz’'s avatar
louiz’ committed
69
70
71
  std::string str = stanza.to_string();
  log_debug("XMPP SENDING: " << str);
  this->send_data(std::move(str));
72
73
}

74
75
76
77
78
void XmppComponent::on_connection_failed(const std::string& reason)
{
  log_error("Failed to connect to the XMPP server: " << reason);
}

79
80
void XmppComponent::on_connected()
{
louiz’'s avatar
louiz’ committed
81
  log_info("connected to XMPP server");
82
  XmlNode node("stream:stream", nullptr);
83
84
  node["xmlns"] = COMPONENT_NS;
  node["xmlns:stream"] = STREAM_NS;
85
  node["to"] = this->served_hostname;
86
  this->send_stanza(node);
louiz’'s avatar
louiz’ committed
87
  this->doc_open = true;
88
89
90
  // We may have some pending data to send: this happens when we try to send
  // some data before we are actually connected.  We send that data right now, if any
  this->send_pending_data();
91
92
93
94
}

void XmppComponent::on_connection_close()
{
louiz’'s avatar
louiz’ committed
95
  log_info("XMPP server closed connection");
96
97
}

98
void XmppComponent::parse_in_buffer(const size_t size)
99
{
100
101
102
103
104
105
106
107
108
109
110
111
  if (!this->in_buf.empty())
    { // This may happen if the parser could not allocate enough space for
      // us. We try to feed it the data that was read into our in_buf
      // instead. If this fails again we are in trouble.
      this->parser.feed(this->in_buf.data(), this->in_buf.size(), false);
      this->in_buf.clear();
    }
  else
    { // Just tell the parser to parse the data that was placed into the
      // buffer it provided to us with GetBuffer
      this->parser.parse(size, false);
    }
112
113
}

louiz’'s avatar
louiz’ committed
114
115
116
117
118
119
120
121
void XmppComponent::shutdown()
{
  for (auto it = this->bridges.begin(); it != this->bridges.end(); ++it)
  {
    it->second->shutdown();
  }
}

louiz’'s avatar
louiz’ committed
122
123
void XmppComponent::clean()
{
louiz’'s avatar
louiz’ committed
124
125
  auto it = this->bridges.begin();
  while (it != this->bridges.end())
louiz’'s avatar
louiz’ committed
126
127
  {
    it->second->clean();
128
    if (it->second->active_clients() == 0)
louiz’'s avatar
louiz’ committed
129
130
131
      it = this->bridges.erase(it);
    else
      ++it;
louiz’'s avatar
louiz’ committed
132
133
134
  }
}

135
136
void XmppComponent::on_remote_stream_open(const XmlNode& node)
{
louiz’'s avatar
louiz’ committed
137
  log_debug("XMPP DOCUMENT OPEN: " << node.to_string());
138
139
140
141
142
143
  try
    {
      this->stream_id = node["id"];
    }
  catch (const AttributeNotFound& e)
    {
louiz’'s avatar
louiz’ committed
144
      log_error("Error: no attribute 'id' found");
145
146
147
148
149
      this->send_stream_error("bad-format", "missing 'id' attribute");
      this->close_document();
      return ;
    }

150
  this->last_auth = false;
151
  // Try to authenticate
152
153
154
155
156
157
158
159
160
161
162
  char digest[HASH_LENGTH * 2 + 1];
  sha1nfo sha1;
  sha1_init(&sha1);
  sha1_write(&sha1, this->stream_id.data(), this->stream_id.size());
  sha1_write(&sha1, this->secret.data(),  this->secret.size());
  const uint8_t* result = sha1_result(&sha1);
  for (int i=0; i < HASH_LENGTH; i++)
    sprintf(digest + (i*2), "%02x", result[i]);
  digest[HASH_LENGTH * 2] = '\0';

  Stanza handshake("handshake");
163
164
165
166
167
168
169
  handshake.set_inner(digest);
  handshake.close();
  this->send_stanza(handshake);
}

void XmppComponent::on_remote_stream_close(const XmlNode& node)
{
louiz’'s avatar
louiz’ committed
170
  log_debug("XMPP DOCUMENT CLOSE " << node.to_string());
171
  this->doc_open = false;
172
173
}

174
175
176
177
178
void XmppComponent::reset()
{
  this->parser.reset();
}

179
180
void XmppComponent::on_stanza(const Stanza& stanza)
{
louiz’'s avatar
louiz’ committed
181
  log_debug("XMPP RECEIVING: " << stanza.to_string());
182
  std::function<void(const Stanza&)> handler;
183
184
  try
    {
185
      handler = this->stanza_handlers.at(stanza.get_name());
186
187
188
    }
  catch (const std::out_of_range& exception)
    {
louiz’'s avatar
louiz’ committed
189
      log_warning("No handler for stanza of type " << stanza.get_name());
190
191
      return;
    }
192
  handler(stanza);
193
194
195
196
197
198
}

void XmppComponent::send_stream_error(const std::string& name, const std::string& explanation)
{
  XmlNode node("stream:error", nullptr);
  XmlNode error(name, nullptr);
199
  error["xmlns"] = STREAM_NS;
200
201
202
203
204
205
206
207
  if (!explanation.empty())
    error.set_inner(explanation);
  error.close();
  node.add_child(std::move(error));
  node.close();
  this->send_stanza(node);
}

208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
void XmppComponent::send_stanza_error(const std::string& kind, const std::string& to, const std::string& from,
                       const std::string& id, const std::string& error_type,
                       const std::string& defined_condition, const std::string& text)
{
  Stanza node(kind);
  if (!to.empty())
    node["to"] = to;
  if (!from.empty())
    node["from"] = from;
  if (!id.empty())
    node["id"] = id;
  node["type"] = "error";
  XmlNode error("error");
  error["type"] = error_type;
  XmlNode inner_error(defined_condition);
  inner_error["xmlns"] = STANZA_NS;
  inner_error.close();
  error.add_child(std::move(inner_error));
  if (!text.empty())
    {
      XmlNode text_node("text");
      text_node["xmlns"] = STANZA_NS;
      text_node.set_inner(text);
      text_node.close();
      error.add_child(std::move(text_node));
    }
  error.close();
  node.add_child(std::move(error));
  node.close();
  this->send_stanza(node);
}

240
241
void XmppComponent::close_document()
{
louiz’'s avatar
louiz’ committed
242
  log_debug("XMPP SENDING: </stream:stream>");
243
  this->send_data("</stream:stream>");
louiz’'s avatar
louiz’ committed
244
  this->doc_open = false;
245
246
247
248
}

void XmppComponent::handle_handshake(const Stanza& stanza)
{
249
  (void)stanza;
250
  this->authenticated = true;
251
252
  this->ever_auth = true;
  this->last_auth = true;
louiz’'s avatar
louiz’ committed
253
  log_info("Authenticated with the XMPP server");
254
}
255
256
257

void XmppComponent::handle_presence(const Stanza& stanza)
{
258
  std::string from;
259
260
261
  std::string id;
  try {
    id = stanza["id"];
262
    from = stanza["from"];
263
  } catch (const AttributeNotFound&) {}
264
265
266
267
  if (from.empty())
    return;
  utils::ScopeGuard malformed_stanza_error([&](){
      this->send_stanza_error("presence", from, this->served_hostname, id,
268
269
                              "modify", "bad-request", "");
        });
270
271
272
  Bridge* bridge = this->get_user_bridge(stanza["from"]);
  Jid to(stanza["to"]);
  Iid iid(to.local);
louiz’'s avatar
louiz’ committed
273
274
275
276
277
  std::string type;
  try {
    type = stanza["type"];
  }
  catch (const AttributeNotFound&) {}
278
279
280
281
282
283
284
285
286
287
  malformed_stanza_error.disable();

  // An error stanza is sent whenever we exit this function without
  // disabling this scopeguard.  If error_type and error_name are not
  // changed, the error signaled is internal-server-error. Change their
  // value to signal an other kind of error. For example
  // feature-not-implemented, etc.  Any non-error process should reach the
  // stanza_error.disable() call at the end of the function.
  std::string error_type("cancel");
  std::string error_name("internal-server-error");
288
  utils::ScopeGuard stanza_error([&](){
289
290
291
      this->send_stanza_error("presence", stanza["from"], stanza["to"], id,
                              error_type, error_name, "");
        });
louiz’'s avatar
louiz’ committed
292

293
  if (!iid.chan.empty() && !iid.server.empty())
louiz’'s avatar
louiz’ committed
294
295
    { // presence toward a MUC that corresponds to an irc channel
      if (type.empty())
louiz’'s avatar
louiz’ committed
296
297
298
299
        {
          const std::string own_nick = bridge->get_own_nick(iid);
          if (!own_nick.empty() && own_nick != to.resource)
            bridge->send_irc_nick_change(iid, to.resource);
300
          bridge->join_irc_channel(iid, to.resource);
louiz’'s avatar
louiz’ committed
301
        }
louiz’'s avatar
louiz’ committed
302
303
      else if (type == "unavailable")
        {
304
          XmlNode* status = stanza.get_child(COMPONENT_NS":status");
louiz’'s avatar
louiz’ committed
305
306
307
          bridge->leave_irc_channel(std::move(iid), status ? std::move(status->get_inner()) : "");
        }
    }
308
309
310
311
312
313
  else
    {
      // An user wants to join an invalid IRC channel, return a presence error to him
      if (type.empty())
        this->send_invalid_room_error(to.local, to.resource, stanza["from"]);
    }
314
  stanza_error.disable();
315
316
}

louiz’'s avatar
louiz’ committed
317
318
void XmppComponent::handle_message(const Stanza& stanza)
{
319
  std::string from;
320
321
322
  std::string id;
  try {
    id = stanza["id"];
323
    from = stanza["from"];
324
  } catch (const AttributeNotFound&) {}
325
326
327
328
  if (from.empty())
    return;
  utils::ScopeGuard malformed_stanza_error([&](){
      this->send_stanza_error("message", from, this->served_hostname, id,
329
330
                              "modify", "bad-request", "");
        });
louiz’'s avatar
louiz’ committed
331
332
333
  Bridge* bridge = this->get_user_bridge(stanza["from"]);
  Jid to(stanza["to"]);
  Iid iid(to.local);
334
335
336
337
338
339
340
341
342
  std::string type;
  try {
    type = stanza["type"];
  }
  catch (const AttributeNotFound&) {}
  malformed_stanza_error.disable();

  std::string error_type("cancel");
  std::string error_name("internal-server-error");
343
  utils::ScopeGuard stanza_error([&](){
344
345
346
      this->send_stanza_error("message", stanza["from"], stanza["to"], id,
                              error_type, error_name, "");
        });
347
  XmlNode* body = stanza.get_child(COMPONENT_NS":body");
348
  if (type == "groupchat")
louiz’'s avatar
louiz’ committed
349
350
351
352
    {
      if (to.resource.empty())
        if (body && !body->get_inner().empty())
          bridge->send_channel_message(iid, body->get_inner());
353
354
355
      XmlNode* subject = stanza.get_child(COMPONENT_NS":subject");
      if (subject)
        bridge->set_channel_topic(iid, subject->get_inner());
louiz’'s avatar
louiz’ committed
356
    }
louiz’'s avatar
louiz’ committed
357
358
359
360
361
  else
    {
      if (body && !body->get_inner().empty())
        bridge->send_private_message(iid, body->get_inner());
    }
362
  stanza_error.disable();
louiz’'s avatar
louiz’ committed
363
364
}

365
366
void XmppComponent::handle_iq(const Stanza& stanza)
{
367
  std::string id;
368
  std::string from;
369
370
  try {
    id = stanza["id"];
371
    from = stanza["from"];
372
  } catch (const AttributeNotFound&) {}
373
374
375
376
  if (from.empty())
    return;
  utils::ScopeGuard malformed_stanza_error([&](){
      this->send_stanza_error("iq", from, this->served_hostname, id,
377
378
                              "modify", "bad-request", "");
        });
379
380
  Bridge* bridge = this->get_user_bridge(stanza["from"]);
  Jid to(stanza["to"]);
381
382
383
384
385
  std::string type = stanza["type"];
  malformed_stanza_error.disable();

  std::string error_type("cancel");
  std::string error_name("internal-server-error");
386
  utils::ScopeGuard stanza_error([&](){
387
388
389
      this->send_stanza_error("iq", stanza["from"], stanza["to"], id,
                              error_type, error_name, "");
        });
390
391
392
393
394
  if (type == "set")
    {
      XmlNode* query;
      if ((query = stanza.get_child(MUC_ADMIN_NS":query")))
        {
395
396
          const XmlNode* child = query->get_child(MUC_ADMIN_NS":item");
          if (child)
397
398
399
400
401
402
403
404
            {
              std::string nick;
              std::string role;
              try {
                nick = (*child)["nick"];
                role = (*child)["role"];
              }
              catch (const AttributeNotFound&)
405
406
407
408
409
                {
                  error_type = "modify";
                  error_name = "bad-request";
                  return;
                }
410
411
412
413
414
415
416
417
418
419
420
421
              if (!nick.empty() && role == "none")
                {
                  std::string reason;
                  XmlNode* reason_el = child->get_child(MUC_ADMIN_NS":reason");
                  if (reason_el)
                    reason = reason_el->get_inner();
                  Iid iid(to.local);
                  bridge->send_irc_kick(iid, nick, reason);
                }
            }
        }
    }
422
423
424
425
426
427
428
  else
    {
      error_type = "cancel";
      error_name = "feature-not-implemented";
      return;
    }
  stanza_error.disable();
429
430
}

louiz’'s avatar
louiz’ committed
431
432
433
434
435
436
437
438
439
void XmppComponent::handle_error(const Stanza& stanza)
{
  XmlNode* text = stanza.get_child(STREAMS_NS":text");
  std::string error_message("Unspecified error");
  if (text)
    error_message = text->get_inner();
  log_error("Stream error received from the XMPP server: " << error_message);
}

440
441
442
443
444
445
446
447
448
449
450
451
452
Bridge* XmppComponent::get_user_bridge(const std::string& user_jid)
{
  try
    {
      return this->bridges.at(user_jid).get();
    }
  catch (const std::out_of_range& exception)
    {
      this->bridges.emplace(user_jid, std::make_unique<Bridge>(user_jid, this, this->poller));
      return this->bridges.at(user_jid).get();
    }
}

453
454
455
456
457
void* XmppComponent::get_receive_buffer(const size_t size) const
{
  return this->parser.get_buffer(size);
}

458
void XmppComponent::send_message(const std::string& from, Xmpp::body&& body, const std::string& to)
459
460
461
462
463
{
  XmlNode node("message");
  node["to"] = to;
  node["from"] = from + "@" + this->served_hostname;
  XmlNode body_node("body");
464
  body_node.set_inner(std::get<0>(body));
465
466
467
468
469
470
  body_node.close();
  node.add_child(std::move(body_node));
  node.close();
  this->send_stanza(node);
}

471
472
473
void XmppComponent::send_user_join(const std::string& from,
                                   const std::string& nick,
                                   const std::string& realjid,
474
475
476
477
                                   const std::string& affiliation,
                                   const std::string& role,
                                   const std::string& to,
                                   const bool self)
478
479
480
481
482
483
{
  XmlNode node("presence");
  node["to"] = to;
  node["from"] = from + "@" + this->served_hostname + "/" + nick;

  XmlNode x("x");
484
  x["xmlns"] = MUC_USER_NS;
485
486

  XmlNode item("item");
487
488
489
490
  if (!affiliation.empty())
    item["affiliation"] = affiliation;
  if (!role.empty())
    item["role"] = role;
491
492
493
494
495
496
  if (!realjid.empty())
    {
      const std::string preped_jid = jidprep(realjid);
      if (!preped_jid.empty())
        item["jid"] = preped_jid;
    }
497
  item.close();
498
  x.add_child(std::move(item));
499

500
501
502
503
504
505
506
  if (self)
    {
      XmlNode status("status");
      status["code"] = "110";
      status.close();
      x.add_child(std::move(status));
    }
507
508
509
510
511
512
  x.close();
  node.add_child(std::move(x));
  node.close();
  this->send_stanza(node);
}

513
514
515
516
517
518
519
520
521
522
523
524
525
526
void XmppComponent::send_invalid_room_error(const std::string& muc_name,
                                            const std::string& nick,
                                            const std::string& to)
{
  Stanza presence("presence");
  presence["from"] = muc_name + "@" + this->served_hostname + "/" + nick;
  presence["to"] = to;
  presence["type"] = "error";
  XmlNode x("x");
  x["xmlns"] = MUC_NS;
  x.close();
  presence.add_child(std::move(x));
  XmlNode error("error");
  error["by"] = muc_name + "@" + this->served_hostname;
louiz’'s avatar
Idem    
louiz’ committed
527
  error["type"] = "cancel";
louiz’'s avatar
louiz’ committed
528
529
530
531
  XmlNode item_not_found("item-not-found");
  item_not_found["xmlns"] = STANZA_NS;
  item_not_found.close();
  error.add_child(std::move(item_not_found));
532
533
534
535
536
537
538
539
540
541
542
543
544
545
  XmlNode text("text");
  text["xmlns"] = STANZA_NS;
  text["xml:lang"] = "en";
  text.set_inner(muc_name +
                 " is not a valid IRC channel name. A correct room jid is of the form: #<chan>%<server>@" +
                 this->served_hostname);
  text.close();
  error.add_child(std::move(text));
  error.close();
  presence.add_child(std::move(error));
  presence.close();
  this->send_stanza(presence);
}

546
void XmppComponent::send_topic(const std::string& from, Xmpp::body&& topic, const std::string& to)
547
548
549
550
551
552
{
  XmlNode message("message");
  message["to"] = to;
  message["from"] = from + "@" + this->served_hostname;
  message["type"] = "groupchat";
  XmlNode subject("subject");
553
  subject.set_inner(std::get<0>(topic));
554
555
556
557
558
  subject.close();
  message.add_child(std::move(subject));
  message.close();
  this->send_stanza(message);
}
louiz’'s avatar
louiz’ committed
559

560
void XmppComponent::send_muc_message(const std::string& muc_name, const std::string& nick, Xmpp::body&& xmpp_body, const std::string& jid_to)
louiz’'s avatar
louiz’ committed
561
562
563
{
  Stanza message("message");
  message["to"] = jid_to;
louiz’'s avatar
louiz’ committed
564
565
566
567
  if (!nick.empty())
    message["from"] = muc_name + "@" + this->served_hostname + "/" + nick;
  else // Message from the room itself
    message["from"] = muc_name + "@" + this->served_hostname;
louiz’'s avatar
louiz’ committed
568
569
  message["type"] = "groupchat";
  XmlNode body("body");
570
  body.set_inner(std::get<0>(xmpp_body));
louiz’'s avatar
louiz’ committed
571
572
  body.close();
  message.add_child(std::move(body));
573
574
575
576
577
578
579
580
581
  if (std::get<1>(xmpp_body))
    {
      XmlNode html("html");
      html["xmlns"] = XHTMLIM_NS;
      // Pass the ownership of the pointer to this xmlnode
      html.add_child(std::get<1>(xmpp_body).release());
      html.close();
      message.add_child(std::move(html));
    }
louiz’'s avatar
louiz’ committed
582
583
584
  message.close();
  this->send_stanza(message);
}
louiz’'s avatar
louiz’ committed
585

586
void XmppComponent::send_muc_leave(std::string&& muc_name, std::string&& nick, Xmpp::body&& message, const std::string& jid_to, const bool self)
louiz’'s avatar
louiz’ committed
587
588
589
590
591
{
  Stanza presence("presence");
  presence["to"] = jid_to;
  presence["from"] = muc_name + "@" + this->served_hostname + "/" + nick;
  presence["type"] = "unavailable";
592
  const std::string message_str = std::get<0>(message);
593
  if (!message_str.empty() || self)
louiz’'s avatar
louiz’ committed
594
595
    {
      XmlNode status("status");
596
597
      if (!message_str.empty())
        status.set_inner(message_str);
louiz’'s avatar
louiz’ committed
598
599
600
601
602
603
604
605
      if (self)
        status["code"] = "110";
      status.close();
      presence.add_child(std::move(status));
    }
  presence.close();
  this->send_stanza(presence);
}
louiz’'s avatar
louiz’ committed
606

607
608
609
610
611
612
613
void XmppComponent::send_nick_change(const std::string& muc_name,
                                     const std::string& old_nick,
                                     const std::string& new_nick,
                                     const std::string& affiliation,
                                     const std::string& role,
                                     const std::string& jid_to,
                                     const bool self)
louiz’'s avatar
louiz’ committed
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
{
  Stanza presence("presence");
  presence["to"] = jid_to;
  presence["from"] = muc_name + "@" + this->served_hostname + "/" + old_nick;
  presence["type"] = "unavailable";
  XmlNode x("x");
  x["xmlns"] = MUC_USER_NS;
  XmlNode item("item");
  item["nick"] = new_nick;
  item.close();
  x.add_child(std::move(item));
  XmlNode status("status");
  status["code"] = "303";
  status.close();
  x.add_child(std::move(status));
  if (self)
    {
      XmlNode status2("status");
      status2["code"] = "110";
      status2.close();
      x.add_child(std::move(status2));
    }
  x.close();
  presence.add_child(std::move(x));
  presence.close();
  this->send_stanza(presence);

641
  this->send_user_join(muc_name, new_nick, "", affiliation, role, jid_to, self);
louiz’'s avatar
louiz’ committed
642
}
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678

void XmppComponent::kick_user(const std::string& muc_name,
                                  const std::string& target,
                                  const std::string& txt,
                                  const std::string& author,
                                  const std::string& jid_to)
{
  Stanza presence("presence");
  presence["from"] = muc_name + "@" + this->served_hostname + "/" + target;
  presence["to"] = jid_to;
  presence["type"] = "unavailable";
  XmlNode x("x");
  x["xmlns"] = MUC_USER_NS;
  XmlNode item("item");
  item["affiliation"] = "none";
  item["role"] = "none";
  XmlNode actor("actor");
  actor["nick"] = author;
  actor["jid"] = author; // backward compatibility with old clients
  actor.close();
  item.add_child(std::move(actor));
  XmlNode reason("reason");
  reason.set_inner(txt);
  reason.close();
  item.add_child(std::move(reason));
  item.close();
  x.add_child(std::move(item));
  XmlNode status("status");
  status["code"] = "307";
  status.close();
  x.add_child(std::move(status));
  x.close();
  presence.add_child(std::move(x));
  presence.close();
  this->send_stanza(presence);
}
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703

void XmppComponent::send_nickname_conflict_error(const std::string& muc_name,
                                                 const std::string& nickname,
                                                 const std::string& jid_to)
{
  Stanza presence("presence");
  presence["from"] = muc_name + "@" + this->served_hostname + "/" + nickname;
  presence["to"] = jid_to;
  XmlNode x("x");
  x["xmlns"] = MUC_NS;
  x.close();
  presence.add_child(std::move(x));
  XmlNode error("error");
  error["by"] = muc_name + "@" + this->served_hostname;
  error["type"] = "cancel";
  error["code"] = "409";
  XmlNode conflict("conflict");
  conflict["xmlns"] = STANZA_NS;
  conflict.close();
  error.add_child(std::move(conflict));
  error.close();
  presence.add_child(std::move(error));
  presence.close();
  this->send_stanza(presence);
}
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725

void XmppComponent::send_affiliation_role_change(const std::string& muc_name,
                                                 const std::string& target,
                                                 const std::string& affiliation,
                                                 const std::string& role,
                                                 const std::string& jid_to)
{
  Stanza presence("presence");
  presence["from"] = muc_name + "@" + this->served_hostname + "/" + target;
  presence["to"] = jid_to;
  XmlNode x("x");
  x["xmlns"] = MUC_USER_NS;
  XmlNode item("item");
  item["affiliation"] = affiliation;
  item["role"] = role;
  item.close();
  x.add_child(std::move(item));
  x.close();
  presence.add_child(std::move(x));
  presence.close();
  this->send_stanza(presence);
}