irc_client.hpp 11.7 KB
Newer Older
1
2
3
#ifndef IRC_CLIENT_INCLUDED
# define IRC_CLIENT_INCLUDED

4
#include <irc/irc_message.hpp>
5
6
#include <irc/irc_channel.hpp>
#include <irc/iid.hpp>
louiz’'s avatar
louiz’ committed
7

8
#include <network/tcp_socket_handler.hpp>
louiz’'s avatar
louiz’ committed
9
#include <network/resolver.hpp>
10

11
#include <unordered_map>
12
#include <utility>
13
#include <memory>
louiz’'s avatar
louiz’ committed
14
#include <vector>
15
#include <string>
louiz’'s avatar
louiz’ committed
16
#include <stack>
louiz’'s avatar
louiz’ committed
17
#include <map>
18
#include <set>
19

20
21
class Bridge;

22
23
24
25
/**
 * Represent one IRC client, i.e. an endpoint connected to a single IRC
 * server, through a TCP socket, receiving and sending commands to it.
 */
26
class IrcClient: public TCPSocketHandler
27
28
{
public:
29
30
  explicit IrcClient(std::shared_ptr<Poller> poller, const std::string& hostname,
                     const std::string& nickname, const std::string& username,
louiz’'s avatar
louiz’ committed
31
                     const std::string& realname, const std::string& user_hostname,
32
                     Bridge& bridge);
33
  ~IrcClient();
34
35
36
37
  /**
   * Connect to the IRC server
   */
  void start();
38
39
40
41
  /**
   * Called when the connection to the server cannot be established
   */
  void on_connection_failed(const std::string& reason) override final;
louiz’'s avatar
louiz’ committed
42
43
44
  /**
   * Called when successfully connected to the server
   */
louiz’'s avatar
louiz’ committed
45
  void on_connected() override final;
46
47
48
  /**
   * Close the connection, remove us from the poller
   */
49
  void on_connection_close(const std::string& error) override final;
50
51
52
53
  /**
   * Parse the data we have received so far and try to get one or more
   * complete messages from it.
   */
54
  void parse_in_buffer(const size_t) override final;
55
56
57
#ifdef BOTAN_FOUND
  virtual bool abort_on_invalid_cert() const override final;
#endif
58
59
60
61
  /**
   * Return the channel with this name, create it if it does not yet exist
   */
  IrcChannel* get_channel(const std::string& name);
louiz’'s avatar
louiz’ committed
62
63
64
65
  /**
   * Returns true if the channel is joined
   */
  bool is_channel_joined(const std::string& name);
louiz’'s avatar
louiz’ committed
66
67
68
69
  /**
   * Return our own nick
   */
  std::string get_own_nick() const;
louiz’'s avatar
louiz’ committed
70
71
72
73
74
75
  /**
   * Serialize the given message into a line, and send that into the socket
   * (actually, into our out_buf and signal the poller that we want to wach
   * for send events to be ready)
   */
  void send_message(IrcMessage&& message);
louiz’'s avatar
louiz’ committed
76
  void send_raw(const std::string& txt);
77
78
79
  /**
   * Send the PONG irc command
   */
louiz’'s avatar
louiz’ committed
80
  void send_pong_command(const IrcMessage& message);
81
82
83
84
85
  /**
   * Do nothing when we receive a PONG command (but also do not log that no
   * handler exist)
   */
  void on_pong(const IrcMessage& message);
86
  void send_ping_command();
louiz’'s avatar
louiz’ committed
87
88
89
90
91
92
93
94
  /**
   * Send the USER irc command
   */
  void send_user_command(const std::string& username, const std::string& realname);
  /**
   * Send the NICK irc command
   */
  void send_nick_command(const std::string& username);
95
  void send_pass_command(const std::string& password);
louiz’'s avatar
louiz’ committed
96
  void send_webirc_command(const std::string& password, const std::string& user_ip);
louiz’'s avatar
louiz’ committed
97
  /**
louiz’'s avatar
louiz’ committed
98
   * Send the JOIN irc command.
louiz’'s avatar
louiz’ committed
99
   */
100
  void send_join_command(const std::string& chan_name, const std::string& password);
louiz’'s avatar
louiz’ committed
101
102
103
104
105
  /**
   * Send a PRIVMSG command for a channel
   * Return true if the message was actually sent
   */
  bool send_channel_message(const std::string& chan_name, const std::string& body);
louiz’'s avatar
louiz’ committed
106
107
108
  /**
   * Send a PRIVMSG command for an user
   */
louiz’'s avatar
louiz’ committed
109
  void send_private_message(const std::string& username, const std::string& body, const std::string& type);
louiz’'s avatar
louiz’ committed
110
111
112
113
  /**
   * Send the PART irc command
   */
  void send_part_command(const std::string& chan_name, const std::string& status_message);
louiz’'s avatar
louiz’ committed
114
115
116
117
  /**
   * Send the MODE irc command
   */
  void send_mode_command(const std::string& chan_name, const std::vector<std::string>& arguments);
118
119
120
121
  /**
   * Send the KICK irc command
   */
  void send_kick_command(const std::string& chan_name, const std::string& target, const std::string& reason);
122
123
124
125
  /**
   * Send the LIST irc command
   */
  void send_list_command();
126
  void send_topic_command(const std::string& chan_name, const std::string& topic);
louiz’'s avatar
louiz’ committed
127
128
129
  /**
   * Send the QUIT irc command
   */
130
  void send_quit_command(const std::string& reason);
131
132
133
134
135
136
  /**
   * Send a message to the gateway user, not generated by the IRC server,
   * but that might be useful because we want to be verbose (for example we
   * might want to notify the user about the connexion state)
   */
  void send_gateway_message(const std::string& message, const std::string& from="");
137
138
139
140
  /**
   * Forward the server message received from IRC to the XMPP component
   */
  void forward_server_message(const IrcMessage& message);
louiz’'s avatar
louiz’ committed
141
142
143
144
145
  /**
   * When receiving the isupport informations.  See
   * http://www.irc.org/tech_docs/draft-brocklesby-irc-isupport-03.txt
   */
  void on_isupport_message(const IrcMessage& message);
louiz’'s avatar
louiz’ committed
146
147
148
149
  /**
   * Does nothing yet. Isn’t that duplicating features from 005?
   */
  void on_server_myinfo(const IrcMessage& message);
150
151
152
153
154
155
156
157
158
159
160
161
  /**
   * Just empty the motd we kept as a string
   */
  void empty_motd(const IrcMessage& message);
  /**
   * Send the MOTD string as one single "big" message
   */
  void send_motd(const IrcMessage& message);
  /**
   * Append this line to the MOTD
   */
  void on_motd_line(const IrcMessage& message);
162
163
164
165
166
  /**
   * Forward the join of an other user into an IRC channel, and save the
   * IrcUsers in the IrcChannel
   */
  void set_and_forward_user_list(const IrcMessage& message);
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
  /**
   * Signal the start of the LIST response. The RFC says its obsolete and
   * “not used”, but I we receive it on some servers, so just ignore it.
   */
  void on_rpl_liststart(const IrcMessage& message);
  /**
   * A single LIST response line (one channel)
   *
   * The command is handled in a wait_irc callback. This general handler is
   * empty and just used to avoid sending a message stanza for each received
   * channel.
   */
  void on_rpl_list(const IrcMessage& message);
  /**
   * Signal the end of the LIST response, ignore.
   */
  void on_rpl_listend(const IrcMessage& message);
184
185
186
187
  /**
   * Remember our nick and host, when we are joined to the channel. The list
   * of user comes after so we do not send the self-presence over XMPP yet.
   */
louiz’'s avatar
louiz’ committed
188
  void on_channel_join(const IrcMessage& message);
louiz’'s avatar
louiz’ committed
189
190
191
192
  /**
   * When a channel message is received
   */
  void on_channel_message(const IrcMessage& message);
193
194
195
196
  /**
   * A notice is received
   */
  void on_notice(const IrcMessage& message);
197
198
199
200
  /**
   * Save the topic in the IrcChannel
   */
  void on_topic_received(const IrcMessage& message);
louiz’'s avatar
louiz’ committed
201
202
203
204
  /**
   * Empty the topic
   */
  void on_empty_topic(const IrcMessage& message);
205
206
207
208
209
  /**
   * The channel has been completely joined (self presence, topic, all names
   * received etc), send the self presence and topic to the XMPP user.
   */
  void on_channel_completely_joined(const IrcMessage& message);
210
211
212
213
  /**
   * We tried to set an invalid nickname
   */
  void on_erroneous_nickname(const IrcMessage& message);
214
215
216
217
218
  /**
   * When the IRC servers denies our nickname because of a conflict.  Send a
   * presence conflict from all channels, because the name is server-wide.
   */
  void on_nickname_conflict(const IrcMessage& message);
219
220
221
222
  /**
   * Idem, but for when the user changes their nickname too quickly
   */
  void on_nickname_change_too_fast(const IrcMessage& message);
223
224
225
226
  /**
   * Handles most errors from the server by just forwarding the message to the user.
   */
  void on_generic_error(const IrcMessage& message);
louiz’'s avatar
louiz’ committed
227
228
229
230
  /**
   * When a message 001 is received, join the rooms we wanted to join, and set our actual nickname
   */
  void on_welcome_message(const IrcMessage& message);
louiz’'s avatar
louiz’ committed
231
  void on_part(const IrcMessage& message);
louiz’'s avatar
louiz’ committed
232
  void on_error(const IrcMessage& message);
louiz’'s avatar
louiz’ committed
233
  void on_nick(const IrcMessage& message);
234
  void on_kick(const IrcMessage& message);
louiz’'s avatar
louiz’ committed
235
  void on_mode(const IrcMessage& message);
louiz’'s avatar
louiz’ committed
236
  /**
louiz’'s avatar
louiz’ committed
237
238
239
   * A mode towards our own user is received (note, that is different from a
   * channel mode towards or own nick, see
   * http://tools.ietf.org/html/rfc2812#section-3.1.5 VS #section-3.2.3)
louiz’'s avatar
louiz’ committed
240
   */
louiz’'s avatar
louiz’ committed
241
  void on_user_mode(const IrcMessage& message);
louiz’'s avatar
louiz’ committed
242
  /**
louiz’'s avatar
louiz’ committed
243
244
   * A mode towards a channel. Note that this can change the mode of the
   * channel itself or an IrcUser in it.
louiz’'s avatar
louiz’ committed
245
   */
louiz’'s avatar
louiz’ committed
246
  void on_channel_mode(const IrcMessage& message);
louiz’'s avatar
louiz’ committed
247
  void on_quit(const IrcMessage& message);
248
  void on_unknown_message(const IrcMessage& message);
249
250
251
252
  /**
   * Return the number of joined channels
   */
  size_t number_of_joined_channels() const;
louiz’'s avatar
louiz’ committed
253
254
255
256
  /**
   * Get a reference to the unique dummy channel
   */
  DummyIrcChannel& get_dummy_channel();
louiz’'s avatar
louiz’ committed
257
258
259
260
261
  /**
   * Leave the dummy channel: forward a message to the user to indicate that
   * he left it, and mark it as not joined.
   */
  void leave_dummy_channel(const std::string& exit_message);
louiz’'s avatar
louiz’ committed
262
263
264
265

  const std::string& get_hostname() const { return this->hostname; }
  std::string get_nick() const { return this->current_nick; }
  bool is_welcomed() const { return this->welcomed; }
266

louiz’'s avatar
louiz’ committed
267
  const Resolver& get_resolver() const { return this->dns_resolver; }
louiz’'s avatar
louiz’ committed
268

269
private:
270
271
272
273
  /**
   * The hostname of the server we are connected to.
   */
  const std::string hostname;
louiz’'s avatar
louiz’ committed
274
275
276
277
278
  /**
   * The hostname of the user.  This is used in the USER and the WEBIRC
   * commands, but only the one in WEBIRC will be used by the IRC server.
   */
  const std::string user_hostname;
279
  /**
280
   * The username used in the USER irc command
281
   */
282
283
284
285
286
  std::string username;
  /**
   * The realname used in the USER irc command
   */
  std::string realname;
louiz’'s avatar
louiz’ committed
287
288
289
290
  /**
   * Our current nickname on the server
   */
  std::string current_nick;
291
  /**
292
   * To communicate back with the bridge
293
   */
294
  Bridge& bridge;
295
296
297
298
  /**
   * The list of joined channels, indexed by name
   */
  std::unordered_map<std::string, std::unique_ptr<IrcChannel>> channels;
louiz’'s avatar
louiz’ committed
299
300
301
302
303
  /**
   * A single channel with a iid of the form "hostname" (normal channel have
   * an iid of the form "chan%hostname".
   */
  DummyIrcChannel dummy_channel;
louiz’'s avatar
louiz’ committed
304
  /**
305
306
307
308
309
   * A list of chan we want to join (tuples with the channel name and the
   * password, if any), but we need a response 001 from the server before
   * sending the actual JOIN commands. So we just keep the channel names in
   * a list, and send the JOIN commands for each of them whenever the
   * WELCOME message is received.
louiz’'s avatar
louiz’ committed
310
   */
311
  std::vector<std::tuple<std::string, std::string>> channels_to_join;
louiz’'s avatar
louiz’ committed
312
313
314
315
  /**
   * This flag indicates that the server is completely joined (connection
   * has been established, we are authentified and we have a nick)
   */
louiz’'s avatar
louiz’ committed
316
  bool welcomed;
louiz’'s avatar
louiz’ committed
317
318
319
320
321
322
  /**
   * See http://www.irc.org/tech_docs/draft-brocklesby-irc-isupport-03.txt section 3.3
   * We store the possible chanmodes in this object.
   * chanmodes[0] contains modes of type A, [1] of type B etc
   */
  std::vector<std::string> chanmodes;
323
324
325
326
327
  /**
   * See http://www.irc.org/tech_docs/draft-brocklesby-irc-isupport-03.txt
   * section 3.5
   */
  std::set<char> chantypes;
328
329
330
331
332
  /**
   * Each motd line received is appended to this string, which we send when
   * the motd is completely received
   */
  std::string motd;
louiz’'s avatar
louiz’ committed
333
334
335
  /**
   * See http://www.irc.org/tech_docs/draft-brocklesby-irc-isupport-03.txt section 3.14
   * The example given would be transformed into
336
   * modes_to_prefix = {{'&', 'a'}, {'*', 'b'}}
louiz’'s avatar
louiz’ committed
337
338
   */
  std::map<char, char> prefix_to_mode;
339
340
341
342
343
  /**
   * Available user modes, sorted from most significant to least significant
   * (for example 'ahov' is a common order).
   */
  std::vector<char> sorted_user_modes;
louiz’'s avatar
louiz’ committed
344
345
346
347
348
349
  /**
   * A list of ports to which we will try to connect, in reverse. Each port
   * is associated with a boolean telling if we should use TLS or not if the
   * connection succeeds on that port.
   */
  std::stack<std::pair<std::string, bool>> ports_to_try;
350
351
352
353
  /**
   * A set of (lowercase) nicknames to which we sent a private message.
   */
  std::set<std::string> nicks_to_treat_as_private;
louiz’'s avatar
louiz’ committed
354
355
356
357
358
  /**
   * DNS resolver, used to resolve the hostname of the user if we are using
   * the WebIRC protocole.
   */
  Resolver dns_resolver;
louiz’'s avatar
louiz’ committed
359

360
361
362
363
364
365
366
  IrcClient(const IrcClient&) = delete;
  IrcClient(IrcClient&&) = delete;
  IrcClient& operator=(const IrcClient&) = delete;
  IrcClient& operator=(IrcClient&&) = delete;
};

#endif // IRC_CLIENT_INCLUDED