* Fixed "Open File" DCC dialog remembering the last viewed location
[konversation:konversation.git] / src / server.h
1 /*
2   This program is free software; you can redistribute it and/or modify
3   it under the terms of the GNU General Public License as published by
4   the Free Software Foundation; either version 2 of the License, or
5   (at your option) any later version.
6 */
7
8 /*
9   Copyright (C) 2002 Dario Abatianni <eisfuchs@tigress.com>
10   Copyright (C) 2005 Ismail Donmez <ismail@kde.org>
11   Copyright (C) 2005-2006 Peter Simonsson <psn@linux.se>
12   Copyright (C) 2005-2006 Eike Hein <hein@kde.org>
13 */
14
15 #ifndef SERVER_H
16 #define SERVER_H
17
18 #include "channelnick.h"
19 #include "inputfilter.h"
20 #include "outputfilter.h"
21 #include "nickinfo.h"
22 #include "sslsocket.h"
23 #include "serversettings.h"
24 #include "servergroupsettings.h"
25
26 #include <qtimer.h>
27 #include <qdict.h>
28
29 #include <qdeepcopy.h>
30
31 #include <ksharedptr.h>
32 #include <kprocess.h>
33 #include <ksocketbase.h>
34 #include <kbufferedsocket.h>
35 #include <kstreamsocket.h>
36
37
38 class Channel;
39 class DccTransfer;
40 class DccTransferPanelItem;
41 class Query;
42 class StatusPanel;
43 class Identity;
44 class RawLog;
45 class ChannelListPanel;
46 class ScriptLauncher;
47 class ServerISON;
48 class QStrList;
49 class ChatWindow;
50 class ViewContainer;
51
52 using namespace KNetwork;
53
54 class Server : public QObject
55 {
56     Q_OBJECT
57
58     public:
59         typedef enum
60         {
61             SSDisconnected,
62             SSConnecting,
63             SSConnected
64         } State;
65         /** Constructor used for connecting to a known server.
66          *  Read in the prefrences to get all the details about the server.
67          */
68         Server(ViewContainer* viewContainer, int serverGroupId, bool clearQuickServerList = true);
69
70         /** Constructor used for a 'fast connect' to a server.
71          *  The details are passed in.  Used for example when the user does "/server irc.somewhere.net"
72          */
73         Server(ViewContainer* viewContainer, const QString& hostName,const QString& port,
74             const QString& channel,const QString& nick, const QString& password, const bool& useSSL=false);
75         ~Server();
76
77         QString getServerName() const;
78         QString getServerGroup() const;
79
80         void resetCurrentServerIndex() { m_currentServerIndex = 0; }
81
82         Konversation::ServerGroupSettingsPtr serverGroupSettings() const { return m_serverGroup; }
83
84         IdentityPtr getIdentity() const;
85
86         bool getUseSSL() const;
87         QString getSSLInfo() const;
88
89         int getPort() const;
90         int getLag() const;
91
92         bool getAutoJoin() const;
93         void setAutoJoin(bool on);
94
95         /** This returns true when we have a socket connection.
96          *      Not necessarily 'online' and ready for commands.
97          *  @see connected()
98          */
99         bool isConnected() const;
100         bool isConnecting() const;
101
102         QString getAutoJoinChannel() const;
103         void setAutoJoinChannel(const QString &channel);
104
105         QString getAutoJoinChannelKey() const;
106         void setAutoJoinChannelKey(const QString &key);
107
108         QString getNextNickname();
109
110         void setIrcName(const QString &newIrcName);
111         QString getIrcName() const;
112
113         void resetNickList(const QString& channelName);
114         void addPendingNickList(const QString& channelName,const QStringList& nickList);
115         void addHostmaskToNick(const QString &sourceNick, const QString &sourceHostmask);
116         Channel* nickJoinsChannel(const QString &channelName, const QString &nickname, const QString &hostmask);
117         void renameNick(const QString &nickname,const QString &newNick);
118         Channel* removeNickFromChannel(const QString &channelName, const QString &nickname, const QString &reason, bool quit=false);
119         void nickWasKickedFromChannel(const QString &channelName, const QString &nickname, const QString &kicker, const QString &reason);
120         void removeNickFromServer(const QString &nickname, const QString &reason);
121
122         void setChannelTypes(const QString &types);
123         QString getChannelTypes() const;
124
125         // extended user modes support
126         void setPrefixes(const QString &modes, const QString& prefixes);
127         void mangleNicknameWithModes(QString &nickname,bool& isAdmin,bool& isOwner,bool &isOp,
128             bool& isHalfop,bool &hasVoice);
129
130         bool isAChannel(const QString &channel) const;
131         bool isNickname(const QString& compare) const;
132
133         QString getNickname() const;
134         QString loweredNickname() const;
135
136         InputFilter* getInputFilter();
137         Konversation::OutputFilter* getOutputFilter();
138
139         void joinChannel(const QString& name, const QString& hostmask);
140         void removeChannel(Channel* channel);
141         void appendServerMessageToChannel(const QString& channel, const QString& type, const QString& message);
142         void appendCommandMessageToChannel(const QString& channel, const QString& command, const QString& message, bool highlight = true);
143         void appendStatusMessage(const QString& type,const QString& message);
144         void appendMessageToFrontmost(const QString& type,const QString& message, bool parseURL = true);
145
146         int getPreLength(const QString& command, const QString& dest);
147
148         void dcopRaw(const QString& command);
149         void dcopSay(const QString& target,const QString& command);
150         void dcopInfo(const QString& string);
151         void ctcpReply(const QString& receiver, const QString& text);
152
153         void setChannelTopic(const QString& channel, const QString& topic);
154                                                   // Overloaded
155         void setChannelTopic(const QString& nickname, const QString& channel, const QString& topic);
156         void updateChannelMode(const QString& nick, const QString& channel, char mode, bool plus, const QString& parameter);
157         void updateChannelModeWidgets(const QString& channel, char mode, const QString& parameter);
158
159         Channel* getChannelByName(const QString& name);
160         Query* getQueryByName(const QString& name);
161         QString parseWildcards(const QString& toParse, const QString& nickname, const QString& channelName, const QString &channelKey, const QStringList &nickList, const QString& parameter);
162         QString parseWildcards(const QString& toParse, const QString& nickname, const QString& channelName, const QString &channelKey, const QString& nick, const QString& parameter);
163
164         QString getAutoJoinCommand() const;
165
166         void autoCommandsAndChannels();
167
168         void sendURIs(const QStrList& uris, const QString& nick);
169
170         void notifyAction(const QString& nick);
171         ChannelListPanel* getChannelListPanel() const;
172
173         StatusPanel* getStatusView() const { return statusView; }
174
175         /** This returns true when we are 'online' - ready to take commands, join channels and so on.
176          */
177         bool connected() const;
178
179         QString getOwnIpByNetworkInterface();
180         QString getOwnIpByServerMessage();
181
182         /**
183          * Returns true if the given nickname is known to be online.
184          * @param nickname      The nickname.  Case insensitive.
185          * @return              True if the nickname is known to be online by the server.
186          * Note that a nick that is not in any of the joined channels and is not on the
187          * notify list, and has not initiated a query with you, may well be online,
188          * but server doesn't know if it is or not, in which case False is returned.
189          */
190         bool isNickOnline(const QString &nickname);
191         /** Given a nickname, returns NickInfo object.
192          *  @param nickname    The desired nickname.  Case insensitive.
193          *  @return            Pointer to the nickinfo for this nickname if one exists.
194          *                     0 if not known to be online.
195          *
196          *  A NickInfo pointer will only be returned if the nickname is known to the Konvi
197          *  Server object.  A nick will be known if:
198          *  - It is in one of the server's channels user has joined.
199          *  - It is on the notify list and is known to be online.
200          *  - The nick initiated a query with the user.
201          *  A NickInfo is destroyed when it is offline.
202          */
203         NickInfoPtr getNickInfo(const QString& nickname);
204         /** Given a nickname, returns an existing NickInfo object, or creates a new NickInfo object.
205          *  Guaranteed to return a nickinfo.
206          *  @param nickname    The desired nickname.  Case sensitive.
207          *  @return            Pointer to the found or created NickInfo object.
208          */
209         NickInfoPtr obtainNickInfo(const QString& nickname);
210         /** Returns a list of all the NickInfos that are online and known to the server.
211          * Caller should not modify the list.
212          * A nick will be known if:
213          *  - It is in one of the server's channels user has joined.
214          *  - It is on the notify list and is known to be online.
215          *  - The nick initiated a query with the user.
216          *
217          * @return A QMap of KSharedPtrs to NickInfos indexed by lowercase nickname.
218          */
219         const NickInfoMap* getAllNicks();
220         /** Returns the list of members for a channel in the joinedChannels list.
221          *  A joinedChannel is one that you are in, as opposed to a channel that you aren't in,
222          *  but one of your watched nicks is in.
223          *  Code that calls this must not modify the list.
224          *  @param channelName Name of desired channel.  Case insensitive.
225          *  @return            A map of all the nicks in the channel.
226          *                     0 if channel is not in the joinedChannels list.
227          */
228         const ChannelNickMap *getJoinedChannelMembers(const QString& channelName) const;
229         /** Returns the list of members for a channel in the unjoinedChannels list.
230          *  An unjoinedChannel is a channel you aren't in.  As such, this is only going to return
231          *  nicks that you know are in that channel because a /whois has been done against them.
232          *  This could be done automatically if they are on the watch list.
233          *  Code that calls this must not modify the list.
234          *  @param channelName Name of desired channel.  Case insensitive.
235          *  @return            A map of only the nicks that we know that are in the channel.
236          *                     0 if channel is not in the unjoinedChannels list.
237          */
238         const ChannelNickMap *getUnjoinedChannelMembers(const QString& channelName) const;
239         /** Searches the Joined and Unjoined lists for the given channel and returns the member list.
240          *  Code that calls this must not modify the list.
241          *  @param channelName Name of desired channel.  Case insensitive.
242          *  @return            A map of nicks in that channel.  0 if channel is not in either list.
243          *
244          *  @see getJoinedChannelMembers(const QString& channelName)
245          *  @see getUnjoinedChannelMembers(const QString& channelName)
246          */
247         const ChannelNickMap *getChannelMembers(const QString& channelName) const;
248         /** Returns a list of all the joined channels that a nick is in.
249          *  @param nickname    The desired nickname.  Case insensitive.
250          *  @return            A list of joined channels the nick is in.  Empty if none.
251          */
252         QStringList getNickJoinedChannels(const QString& nickname);
253         /** Returns a list of all the channels (joined or unjoined) that a nick is in.
254          *  @param nickname    The desired nickname.  Case insensitive.
255          *  @return            A list of channels the nick is in.  Empty if none.
256          *
257          *  A nick will not appear in the Unjoined channels list unless a WHOIS
258          *  has been performed on it.
259          */
260         QStringList getNickChannels(const QString& nickname);
261         /** Returns pointer to the ChannelNick (mode and pointer to NickInfo) for a
262          *  given channel and nickname.
263          *  @param channelName The desired channel name.  Case insensitive.
264          *  @param nickname    The desired nickname.  Case insensitive.
265          *  @return            Pointer to ChannelNick structure containing a pointer
266          *                     to the NickInfo and the mode of the nick in the channel.
267          *                     0 if not found.
268          */
269         ChannelNickPtr getChannelNick(const QString& channelName, const QString& nickname);
270         /** Updates a nickname in a channel.  If not on the joined or unjoined lists, and nick
271          *  is in the watch list, adds the channel and nick to the unjoinedChannels list.
272          *  If mode != 99, sets the mode for the nick in the channel.
273          *  Returns the NickInfo object if nick is on any lists, otherwise 0.
274          *  @param channelName The channel name.  Case sensitive.
275          *  @param nickname    The nickname.  Case sensitive.
276          *  @param mode        Bit mask containing the modes the nick has in the channel,
277          *                     or 99 if not known.  See channelnick.cpp for bit definitions.
278          */
279         ChannelNickPtr setChannelNick(const QString& channelName, const QString& nickname, unsigned int mode = 99);
280         /**
281          * Given the nickname of nick that is offline (or at least not known to be online),
282          * returns the addressbook entry (if any) for the nick.
283          * @param nickname       Desired nickname.  Case insensitive.
284          * @return               Addressbook entry of the nick or empty if not found.
285          */
286         KABC::Addressee getOfflineNickAddressee(QString& nickname);
287
288         /**
289          * Returns a QPtrList of all channels
290          */
291         QPtrList<Channel> getChannelList() const { return channelList; }
292
293         /** Returns the time we have been away for.
294          *  If we are not away, returns 00:00:00
295          */
296         QString awayTime() const;
297         /** Does the _server_ think we are away.  Note that if we went auto-away when not connected to the server, this may
298          *  return false.
299          */
300         bool isAway() const;
301         void setAwayReason(const QString& reason);
302
303         void emitChannelNickChanged(const ChannelNickPtr channelNick);
304         void emitNickInfoChanged(const NickInfoPtr nickInfo);
305
306         /**
307          * Returns a list of all the nicks on the user watch list plus nicks in the addressbook.
308          */
309         QStringList getWatchList();
310         QString getWatchListString();
311         /**
312          * Return true if the given nickname is on the watch list.
313          */
314         bool isWatchedNick(const QString& nickname);
315         /**
316          * Returns a list of all the nicks on the watch list that are not in joined
317          * channels.  ISON command is sent for these nicks.
318          */
319         QStringList getISONList();
320         QString getISONListString();
321
322         ViewContainer* getViewContainer() const;
323
324         /** Adds a nickname to the joinedChannels list.
325          *  Creates new NickInfo if necessary.
326          *  If needed, moves the channel from the unjoined list to the joined list.
327          *  If needed, moves the nickname from the Offline to Online lists.
328          *  If mode != 99 sets the mode for this nick in this channel.
329          *  @param channelName The channel name.  Case sensitive.
330          *  @param nickname    The nickname.  Case sensitive.
331          *  @return            The NickInfo for the nickname.
332          */
333         ChannelNickPtr addNickToJoinedChannelsList(const QString& channelName, const QString& nickname);
334
335         void setAllowedChannelModes(const QString& modes) { m_allowedChannelModes = modes; }
336         QString allowedChannelModes() const { return m_allowedChannelModes; }
337
338         void registerWithServices();
339
340         // Blowfish stuff
341         QCString getKeyForRecipient(const QString& recipient) const;
342         void setKeyForRecipient(const QString& recipient, const QCString& key);
343
344         bool identifyMsg() const { return m_identifyMsg; }
345
346         ChannelListPanel* addChannelListPanel();
347
348         // invoked by DccTransferSend
349         void dccSendRequest(const QString& recipient,const QString& fileName,const QString& address,const QString& port,unsigned long size);
350         void dccPassiveSendRequest(const QString& recipient,const QString& fileName,const QString& address,unsigned long size,const QString& token);
351         // invoked by DccTransferRecv
352         void dccResumeGetRequest(const QString& sender,const QString& fileName,const QString& port,KIO::filesize_t startAt);
353         void dccReverseSendAck(const QString& partnerNick,const QString& fileName,const QString& ownAddress,const QString& ownPort,unsigned long size,const QString& reverseToken);
354
355     signals:
356         void nicknameChanged(const QString&);
357         void serverLag(Server* server,int msec);  /// will be connected to KonversationMainWindow::updateLag()
358         void tooLongLag(Server* server, int msec);/// will be connected to KonversationMainWindow::updateLag()
359         void resetLag();
360                                                   /// Will be emitted when new 303 came in
361         void nicksNowOnline(Server* server,const QStringList& list,bool changed);
362         void deleted(Server* myself);             /// will be connected to KonversationApplication::removeServer()
363         void awayState(bool away);                /// will be connected to any user input panel;
364         void multiServerCommand(const QString& command, const QString& parameter);
365
366         /// Emitted when the server gains/loses connection.
367         void serverOnline(bool state);            /// will be connected to all server dependant tabs
368
369         /// Note that these signals haven't been implemented yet.
370         /// Fires when the information in a NickInfo object changes.
371         void nickInfoChanged(Server* server, const NickInfoPtr nickInfo);
372         /// Fires when the mode of a nick in a channel changes.
373         void channelNickChanged(Server* server, const ChannelNickPtr channelNick);
374         /// Fires when a nick leaves or joins a channel.  Based on joined flag, receiver could
375         /// call getJoinedChannelMembers or getUnjoinedChannelMembers, or just
376         /// getChannelMembers to get a list of all the nicks now in the channel.
377         /// parted indicates whether the nick joined or left the channel.
378         void channelMembersChanged(Server* server, const QString& channelName, bool joined, bool parted, const QString& nickname);
379         /// Fires when a channel is moved to/from the Joinied/Unjoined lists.
380         /// joined indicates which list it is now on.  Note that if joined is False, it is
381         /// possible the channel does not exist in any list anymore.
382         void channelJoinedOrUnjoined(Server* server, const QString& channelName, bool joined);
383         /// Fires when a nick on the watch list goes online or offline.
384         void watchedNickChanged(Server* server, const QString& nickname, bool online);
385         ///Fires when the user switches his state to away and has enabled "Insert Remember Line on away" in his identity.
386         void awayInsertRememberLine(Server* server);
387         void sslInitFailure();
388         void sslConnected(Server* server);
389
390         void connectionChangedState(Server* server, Server::State state);
391
392         void showView(ChatWindow* view);
393         void addDccPanel();
394         void addDccChat(const QString& myNick,const QString& nick,const QStringList& arguments,bool listen);
395
396     public slots:
397         void lookupFinished();
398         void connectToIRCServer();
399         void queue(const QString &buffer);
400         void queueList(const QStringList &buffer);
401         void queueAt(uint pos,const QString& buffer);
402         void setNickname(const QString &newNickname);
403         /** This is called when we want to open a new query, or focus an existing one.
404          *  @param nickInfo The nickinfo we want to open the query to.  Must exist.
405          *  @param weinitiated This is whether we initiated this - did we do /query, or somebody else sending us a message.
406          *  @return A pointer to a new or already-existing query.  Guaranteed to be non-null
407          */
408         Query *addQuery(const NickInfoPtr & nickInfo, bool weinitiated);
409         void closeQuery(const QString &name);
410         void closeChannel(const QString &name);
411         void quitServer();
412         void openDccChat(const QString& nickname);
413         void requestDccChat(const QString& partnerNick, const QString& numericalOwnIp, const QString& ownPort);
414         void requestBan(const QStringList& users,const QString& channel,const QString& option);
415         void requestUnban(const QString& mask,const QString& channel);
416
417         void addDccSend(const QString &recipient,KURL fileURL, const QString &altFileName = QString(), uint fileSize = 0);
418         void removeQuery(Query *query);
419         void startNotifyTimer(int msec=0);
420         void sendJoinCommand(const QString& channelName, const QString& password = QString());
421         void requestChannelList();
422         void requestWhois(const QString& nickname);
423         void requestWho(const QString& channel);
424         void requestUserhost(const QString& nicks);
425         void requestTopic(const QString& channel);
426         void resolveUserhost(const QString& nickname);
427         void addRawLog(bool show);
428         void closeRawLog();
429         void addToChannelList(const QString& channel, int users, const QString& topic);
430         void closeChannelListPanel();
431         void updateChannelQuickButtons();
432         void sendMultiServerCommand(const QString& command, const QString& parameter);
433         void executeMultiServerCommand(const QString& command, const QString& parameter);
434         void reconnect();
435         void disconnect();
436         void connectToServerGroup(const QString& serverGroup);
437         void connectToNewServer(const QString& server, const QString& port, const QString& password);
438         void showSSLDialog();
439         void sendToAllChannels(const QString& text);
440         void notifyTimeout();
441
442         void enableIdentifyMsg(bool enabled);
443         bool identifyMsgEnabled();
444         void addBan(const QString &channel, const QString &ban);
445         void removeBan(const QString &channel, const QString &ban);
446
447         /// Called when we received a PONG from the server
448         void pongReceived();
449
450     protected slots:
451
452         void preShellCommandExited(KProcess*);
453         void ircServerConnectionSuccess();
454         void startAwayTimer();
455         void lockSending();
456         void unlockSending();
457         void incoming();
458         void processIncomingData();
459         void send();
460         /**
461          *Because KBufferedSocket has no closed(int) signal we use this slot to call broken(0)
462          */
463         void closed();
464         void broken(int state);
465         /** This is connected to the SSLSocket failed.
466          * @param reason The reason why this failed.  This is already translated, ready to show the user.
467          */
468         void sslError(const QString& reason);
469         void connectionEstablished(const QString& ownHost);
470         void notifyResponse(const QString& nicksOnline);
471         void slotNewDccTransferItemQueued(DccTransfer* transfer);
472         void startReverseDccSendTransfer(const QString& sourceNick,const QStringList& dccArguments);
473         void addDccGet(const QString& sourceNick,const QStringList& dccArguments);
474         void requestDccSend();                    // -> to outputFilter, dccPanel
475                                                   // -> to outputFilter
476         void requestDccSend(const QString& recipient);
477                                                   // -> to inputFilter
478         void resumeDccGetTransfer(const QString& sourceNick,const QStringList& dccArguments);
479                                                   // -> to inputFilter
480         void resumeDccSendTransfer(const QString& sourceNick,const QStringList& dccArguments);
481         void dccGetDone(DccTransfer* item);
482         void dccSendDone(DccTransfer* item);
483         void dccStatusChanged(DccTransfer* item, int newStatus, int oldStatus);
484         void away();
485         void unAway();
486         void scriptNotFound(const QString& name);
487         void scriptExecutionError(const QString& name);
488         void userhost(const QString& nick,const QString& hostmask,bool away,bool ircOp);
489         void setTopicAuthor(const QString& channel,const QString& author);
490         void endOfWho(const QString& target);
491         void invitation(const QString& nick,const QString& channel);
492         void sendToAllChannelsAndQueries(const QString& text);
493         void gotOwnResolvedHostByWelcome(KResolverResults res);
494         void gotOwnResolvedHostByUserhost(KResolverResults res);
495
496         /// Send a PING to the server so we can meassure the lag
497         void sendPing();
498         /// Updates GUI when the lag gets high
499         void updateLongPongLag();
500
501         /**
502          * Reset the message count used for flood protection, called when the m_messageCountRestTimer times out.
503          */
504         void resetMessageCount();
505
506         /// Update the encoding shown in the mainwindow's actions
507         void updateEncoding();
508
509     protected:
510         // constants
511         static const int BUFFER_LEN=513;
512
513         /// Initialize the class
514         void init(ViewContainer* viewContainer, const QString& nick, const QString& channel);
515
516         /// Initialize the timers
517         void initTimers();
518
519         /// Connect to the signals used in this class.
520         void connectSignals();
521
522         void setViewContainer(ViewContainer* newViewContainer);
523
524         void autoRejoinChannels();
525         void updateAutoJoin(const QString& channel=QString());
526
527         /** Adds a nickname to the unjoinedChannels list.
528          *  Creates new NickInfo if necessary.
529          *  If needed, moves the channel from the joined list to the unjoined list.
530          *  If needed, moves the nickname from the Offline to the Online list.
531          *  If mode != 99 sets the mode for this nick in this channel.
532          *  @param channelName The channel name.  Case sensitive.
533          *  @param nickname    The nickname.  Case sensitive.
534          *  @return            The NickInfo for the nickname.
535          */
536         ChannelNickPtr addNickToUnjoinedChannelsList(const QString& channelName, const QString& nickname);
537         /**
538          * If not already online, changes a nick to the online state by creating
539          * a NickInfo for it and emits various signals and messages for it.
540          * This method should only be called for nicks on the watch list.
541          * @param nickname           The nickname that is online.
542          * @return                   Pointer to NickInfo for nick.
543          */
544         NickInfoPtr setWatchedNickOnline(const QString& nickname);
545         /**
546         * Display offline notification for a certain nickname. The function doesn't change NickInfo objects.
547         * If NickInfoPtr is given, then also the integration with KAddressBook is engaged (i.e. the
548         * nick is marked as away)
549         * @param nickname           The nickname that is offline
550         * @param nickInfo           Pointer to NickInfo for nick
551         */
552         void setWatchedNickOffline(const QString& nickname, const NickInfoPtr nickInfo);
553         /**
554          * If nickname is no longer on any channel list, or the query list, delete it altogether.
555          * Call this routine only if the nick is not on the notify list or is on the notify
556          * list but is known to be offline.
557          * @param nickname           The nickname to be deleted.  Case insensitive.
558          * @return                   True if the nickname is deleted.
559          */
560         bool deleteNickIfUnlisted(const QString &nickname);
561         /**
562          * If not already offline, changes a nick to the offline state.
563          * Removes it from all channels on the joined and unjoined lists.
564          * If the nick is in the watch list, and went offline, emits a signal,
565          * posts a Notify message, and posts a KNotify.
566          * If the nick is in the addressbook, and went offline, informs addressbook of change.
567          * If the nick goes offline, the NickInfo is deleted.
568          *
569          * @param nickname     The nickname.  Case sensitive.
570          * @return             True if the nick was online.
571          */
572         bool setNickOffline(const QString& nickname);
573         /** Remove nickname from a channel (on joined or unjoined lists).
574          *  @param channelName The channel name.  Case insensitive.
575          *  @param nickname    The nickname.  Case insensitive.
576          */
577         void removeChannelNick(const QString& channelName, const QString& nickname);
578         /** Remove channel from the joined list.
579          *  Nicknames in the channel are added to the unjoined list if they are in the watch list.
580          *  @param channelName The channel name.  Case insensitive.
581          */
582         void removeJoinedChannel(const QString& channelName);
583         /** Renames a nickname in all NickInfo lists.
584          *  @param nickInfo    Pointer to existing NickInfo object.
585          *  @param newname     New nickname for the nick.  Case sensitive.
586          */
587         void renameNickInfo(NickInfoPtr nickInfo, const QString& newname);
588
589         /** Called in the server constructor if the preferences are set to run a command on a new server instance.
590          *  This sets up the kprocess, runs it, and connects the signals to call preShellCommandExited when done. */
591         void doPreShellCommand();
592
593         unsigned int completeQueryPosition;
594         unsigned int tryNickNumber;
595         unsigned int reconnectCounter;
596
597         QString bot;
598         QString botPassword;
599
600         // TODO roll these into a QMap.
601         QString serverNickPrefixes;               // Prefixes used by the server to indicate a mode
602         QString serverNickPrefixModes;            // if supplied: modes related to those prefixes
603         QString channelPrefixes;                  // prefixes that indicate channel names. defaults to RFC1459 "#&"
604
605         bool autoJoin;
606         bool quickConnect;
607         bool deliberateQuit;
608         bool keepViewsOpenAfterQuit;
609         bool reconnectAfterQuit;
610
611         QString autoJoinChannel;
612         QString autoJoinChannelKey;
613
614         ViewContainer* m_viewContainerPtr;
615
616         KNetwork::KStreamSocket* m_socket;
617         bool         m_tryReconnect;
618
619         QTimer reconnectTimer;
620         QTimer incomingTimer;
621         QTimer outgoingTimer;
622         QTimer unlockTimer;                       // timeout waiting for server to send initial messages
623
624         QTimer notifyTimer;
625         QStringList notifyCache;                  // List of users found with ISON
626         int checkTime;                            // Time elapsed while waiting for server 303 response
627         int currentLag;
628
629         QString ircName;
630         QCString inputBufferIncomplete;
631         QStringList inputBuffer;
632         QStringList outputBuffer;
633         QString m_nickname;
634         QString m_loweredNickname;
635         QString ownIpByUserhost;                  // RPL_USERHOST
636         QString ownIpByWelcome;                   // RPL_WELCOME
637
638         QPtrList<Channel> channelList;
639         QPtrList<Query> queryList;
640
641         InputFilter inputFilter;
642         Konversation::OutputFilter* outputFilter;
643
644         StatusPanel* statusView;
645         RawLog* rawLog;
646         ChannelListPanel* channelListPanel;
647
648         bool m_isAway;
649         QString m_awayReason;
650
651         bool alreadyConnected;
652         bool rejoinChannels;
653         bool sendUnlocked;
654         bool connecting;
655
656         QString nonAwayNick;
657
658         int m_awayTime;
659
660         ScriptLauncher* m_scriptLauncher;
661
662         KProcess preShellCommand;
663
664     private:
665         /// The server we're going to connect to initially.
666         Konversation::ServerSettings m_quickServer;
667
668         /// Helper object to construct ISON (notify) list and map offline nicks to
669         /// addressbook.
670         ServerISON* m_serverISON;
671         /// All nicks known to this server.  Note this is NOT a list of all nicks on the server.
672         /// Any nick appearing in this list is online, but may not necessarily appear in
673         /// any of the joined or unjoined channel lists because a WHOIS has not yet been
674         /// performed on the nick.
675         NickInfoMap m_allNicks;
676         /// List of membership lists for joined channels.  A "joined" channel is a channel
677         /// that user has joined, i.e., a tab appears for the channel in the main window.
678         ChannelMembershipMap m_joinedChannels;
679         /// List of membership lists for unjoined channels.  These come from WHOIS responses.
680         /// Note that this is NOT a list of all channels on the server, just those we are
681         /// interested in because of nicks in the Nick Watch List.
682         ChannelMembershipMap m_unjoinedChannels;
683         /// List of nicks in Queries.
684         NickInfoMap m_queryNicks;
685
686         Konversation::ServerGroupSettingsPtr m_serverGroup;
687         unsigned int m_currentServerIndex;
688
689         QString m_allowedChannelModes;
690
691         // Blowfish key map
692         QMap<QString,QCString> keyMap;
693
694         bool m_identifyMsg;
695
696         /// Used to lock incomingTimer while processing message.
697         bool m_processingIncoming;
698
699         /// Meassures the lag between PING and PONG
700         QTime m_lagTime;
701         /// Updates the gui when the lag gets too high
702         QTimer m_pingResponseTimer;
703
704         bool m_autoIdentifyLock;
705
706         /// Number of messages sent within a 1 sec interval of each other
707         int m_messageCount;
708         /// Timer to reset the m_messageCount
709         QTimer m_messageCountResetTimer;
710
711         /// Previous ISON reply of the server, needed for comparison with the next reply
712         QStringList m_prevISONList;
713 };
714 #endif