← Back to branch summary

~ubuntu-branches/ubuntu/raring/quassel/raring-proposed

« back to all changes in this revision

Viewing changes to src/common/network.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Harald Sitter
  • Date: 2008-06-27 19:21:30 UTC
  • mto: This revision was merged to the branch mainline in revision 4.
  • Revision ID: james.westby@ubuntu.com-20080627192130-kjsrutd8w40x5okn
Tags: upstream-0.2.0~rc1
Import upstream version 0.2.0~rc1

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/common/network.cpp
19
19
 ***************************************************************************/
20
20
#include "network.h"
21
21
 
22
 
#include "signalproxy.h"
23
 
#include "ircuser.h"
24
 
#include "ircchannel.h"
25
 
 
26
22
#include <QDebug>
27
23
#include <QTextCodec>
28
24
 
31
27
QTextCodec *Network::_defaultCodecForServer = 0;
32
28
QTextCodec *Network::_defaultCodecForEncoding = 0;
33
29
QTextCodec *Network::_defaultCodecForDecoding = 0;
34
 
 
35
30
// ====================
36
31
//  Public:
37
32
// ====================
38
 
Network::Network(const NetworkId &networkid, QObject *parent) : SyncableObject(parent),
 
33
Network::Network(const NetworkId &networkid, QObject *parent)
 
34
  : SyncableObject(parent),
39
35
    _proxy(0),
40
36
    _networkId(networkid),
41
37
    _identity(0),
59
55
  setObjectName(QString::number(networkid.toInt()));
60
56
}
61
57
 
62
 
// I think this is unnecessary since IrcUsers have us as their daddy :)
63
 
 
64
58
Network::~Network() {
65
59
  emit aboutToBeDestroyed();
66
 
//  QHashIterator<QString, IrcUser *> ircuser(_ircUsers);
67
 
//  while (ircuser.hasNext()) {
68
 
//    ircuser.next();
69
 
//    delete ircuser.value();
70
 
//  }
71
 
//  qDebug() << "Destroying net" << networkName() << networkId();
72
 
}
73
 
 
74
 
 
75
 
NetworkId Network::networkId() const {
76
 
  return _networkId;
77
 
}
78
 
 
79
 
SignalProxy *Network::proxy() const {
80
 
  return _proxy;
81
 
}
82
 
 
83
 
void Network::setProxy(SignalProxy *proxy) {
84
 
  _proxy = proxy;
85
 
  //proxy->synchronize(this);  // we should to this explicitly from the outside!
86
 
}
87
 
 
88
 
bool Network::isMyNick(const QString &nick) const {
89
 
  return (myNick().toLower() == nick.toLower());
90
 
}
91
 
 
92
 
bool Network::isMe(IrcUser *ircuser) const {
93
 
  return (ircuser->nick().toLower() == myNick().toLower());
94
60
}
95
61
 
96
62
bool Network::isChannelName(const QString &channelname) const {
103
69
    return QString("#&!+").contains(channelname[0]);
104
70
}
105
71
 
106
 
bool Network::isConnected() const {
107
 
  return _connected;
108
 
}
109
 
 
110
 
//Network::ConnectionState Network::connectionState() const {
111
 
int Network::connectionState() const {
112
 
  return _connectionState;
113
 
}
114
 
 
115
72
NetworkInfo Network::networkInfo() const {
116
73
  NetworkInfo info;
117
74
  info.networkName = networkName();
161
118
    return QString();
162
119
}
163
120
 
164
 
QString Network::prefixToMode(const QCharRef &prefix) {
165
 
  return prefixToMode(QString(prefix));
166
 
}
167
 
 
168
121
QString Network::modeToPrefix(const QString &mode) {
169
122
  if(prefixModes().contains(mode))
170
123
    return QString(prefixes()[prefixModes().indexOf(mode)]);
172
125
    return QString();
173
126
}
174
127
 
175
 
QString Network::modeToPrefix(const QCharRef &mode) {
176
 
  return modeToPrefix(QString(mode));
177
 
}
178
 
  
179
 
QString Network::networkName() const {
180
 
  return _networkName;
181
 
}
182
 
 
183
 
QString Network::currentServer() const {
184
 
  return _currentServer;
185
 
}
186
 
 
187
 
QString Network::myNick() const {
188
 
  return _myNick;
189
 
}
190
 
 
191
 
IdentityId Network::identity() const {
192
 
  return _identity;
193
 
}
194
 
 
195
128
QStringList Network::nicks() const {
196
129
  // we don't use _ircUsers.keys() since the keys may be
197
130
  // not up to date after a nick change
202
135
  return nicks;
203
136
}
204
137
 
205
 
QStringList Network::channels() const {
206
 
  return _ircChannels.keys();
207
 
}
208
 
 
209
 
QVariantList Network::serverList() const {
210
 
  return _serverList;
211
 
}
212
 
 
213
 
bool Network::useRandomServer() const {
214
 
  return _useRandomServer;
215
 
}
216
 
 
217
 
QStringList Network::perform() const {
218
 
  return _perform;
219
 
}
220
 
 
221
 
bool Network::useAutoIdentify() const {
222
 
  return _useAutoIdentify;
223
 
}
224
 
 
225
 
QString Network::autoIdentifyService() const {
226
 
  return _autoIdentifyService;
227
 
}
228
 
 
229
 
QString Network::autoIdentifyPassword() const {
230
 
  return _autoIdentifyPassword;
231
 
}
232
 
 
233
 
bool Network::useAutoReconnect() const {
234
 
  return _useAutoReconnect;
235
 
}
236
 
 
237
 
quint32 Network::autoReconnectInterval() const {
238
 
  return _autoReconnectInterval;
239
 
}
240
 
 
241
 
quint16 Network::autoReconnectRetries() const {
242
 
  return _autoReconnectRetries;
243
 
}
244
 
 
245
 
bool Network::unlimitedReconnectRetries() const {
246
 
  return _unlimitedReconnectRetries;
247
 
}
248
 
 
249
 
bool Network::rejoinChannels() const {
250
 
  return _rejoinChannels;
251
 
}
252
 
 
253
138
QString Network::prefixes() {
254
139
  if(_prefixes.isNull())
255
140
    determinePrefixes();
264
149
  return _prefixModes;
265
150
}
266
151
 
267
 
bool Network::supports(const QString &param) const {
268
 
  return _supports.contains(param);
 
152
// example Unreal IRCD: CHANMODES=beI,kfL,lj,psmntirRcOAQKVCuzNSMTG 
 
153
Network::ChannelModeType Network::channelModeType(const QString &mode) {
 
154
  if(mode.isEmpty())
 
155
    return NOT_A_CHANMODE;
 
156
 
 
157
  QString chanmodes = support("CHANMODES");
 
158
  if(chanmodes.isEmpty())
 
159
    return NOT_A_CHANMODE;
 
160
 
 
161
  ChannelModeType modeType = A_CHANMODE;
 
162
  for(int i = 0; i < chanmodes.count(); i++) {
 
163
    if(chanmodes[i] == mode[0])
 
164
      break;
 
165
    else if(chanmodes[i] == ',')
 
166
      modeType = (ChannelModeType)(modeType << 1);
 
167
  }
 
168
  if(modeType > D_CHANMODE) {
 
169
    qWarning() << "Network" << networkId() << "supplied invalid CHANMODES:" << chanmodes;
 
170
    modeType = NOT_A_CHANMODE;
 
171
  }
 
172
  return modeType;
269
173
}
270
174
 
271
175
QString Network::support(const QString &param) const {
296
200
  return _ircUsers[nick];
297
201
}
298
202
 
299
 
IrcUser *Network::newIrcUser(const QByteArray &hostmask) {
300
 
  return newIrcUser(decodeServerString(hostmask));
301
 
}
302
 
 
303
203
void Network::ircUserDestroyed() {
304
204
  IrcUser *ircUser = static_cast<IrcUser *>(sender());
305
205
  if(!ircUser)
352
252
    return 0;
353
253
}
354
254
 
355
 
IrcUser *Network::ircUser(const QByteArray &nickname) const {
356
 
  return ircUser(decodeServerString(nickname));
357
 
}
358
 
 
359
 
QList<IrcUser *> Network::ircUsers() const {
360
 
  return _ircUsers.values();
361
 
}
362
 
 
363
 
quint32 Network::ircUserCount() const {
364
 
  return _ircUsers.count();
365
 
}
366
 
 
367
255
IrcChannel *Network::newIrcChannel(const QString &channelname) {
368
256
  if(!_ircChannels.contains(channelname.toLower())) {
369
257
    IrcChannel *channel = new IrcChannel(channelname, this);
382
270
  return _ircChannels[channelname.toLower()];
383
271
}
384
272
 
385
 
IrcChannel *Network::newIrcChannel(const QByteArray &channelname) {
386
 
  return newIrcChannel(decodeServerString(channelname));
387
 
}
388
 
 
389
273
IrcChannel *Network::ircChannel(QString channelname) const {
390
274
  channelname = channelname.toLower();
391
275
  if(_ircChannels.contains(channelname))
394
278
    return 0;
395
279
}
396
280
 
397
 
IrcChannel *Network::ircChannel(const QByteArray &channelname) const {
398
 
  return ircChannel(decodeServerString(channelname));
399
 
}
400
 
 
401
 
 
402
 
QList<IrcChannel *> Network::ircChannels() const {
403
 
  return _ircChannels.values();
404
 
}
405
 
 
406
 
quint32 Network::ircChannelCount() const {
407
 
  return _ircChannels.count();
408
 
}
409
 
 
410
281
QByteArray Network::defaultCodecForServer() {
411
 
  if(_defaultCodecForServer) return _defaultCodecForServer->name();
 
282
  if(_defaultCodecForServer)
 
283
    return _defaultCodecForServer->name();
412
284
  return QByteArray();
413
285
}
414
286
 
417
289
}
418
290
 
419
291
QByteArray Network::defaultCodecForEncoding() {
420
 
  if(_defaultCodecForEncoding) return _defaultCodecForEncoding->name();
 
292
  if(_defaultCodecForEncoding)
 
293
    return _defaultCodecForEncoding->name();
421
294
  return QByteArray();
422
295
}
423
296
 
426
299
}
427
300
 
428
301
QByteArray Network::defaultCodecForDecoding() {
429
 
  if(_defaultCodecForDecoding) return _defaultCodecForDecoding->name();
 
302
  if(_defaultCodecForDecoding)
 
303
    return _defaultCodecForDecoding->name();
430
304
  return QByteArray();
431
305
}
432
306
 
435
309
}
436
310
 
437
311
QByteArray Network::codecForServer() const {
438
 
  if(_codecForServer) return _codecForServer->name();
 
312
  if(_codecForServer)
 
313
    return _codecForServer->name();
439
314
  return QByteArray();
440
315
}
441
316
 
449
324
}
450
325
 
451
326
QByteArray Network::codecForEncoding() const {
452
 
  if(_codecForEncoding) return _codecForEncoding->name();
 
327
  if(_codecForEncoding)
 
328
    return _codecForEncoding->name();
453
329
  return QByteArray();
454
330
}
455
331
 
463
339
}
464
340
 
465
341
QByteArray Network::codecForDecoding() const {
466
 
  if(_codecForDecoding) return _codecForDecoding->name();
 
342
  if(_codecForDecoding)
 
343
    return _codecForDecoding->name();
467
344
  else return QByteArray();
468
345
}
469
346
 
478
355
 
479
356
// FIXME use server encoding if appropriate
480
357
QString Network::decodeString(const QByteArray &text) const {
481
 
  if(_codecForDecoding) return ::decodeString(text, _codecForDecoding);
 
358
  if(_codecForDecoding)
 
359
    return ::decodeString(text, _codecForDecoding);
482
360
  else return ::decodeString(text, _defaultCodecForDecoding);
483
361
}
484
362
 
493
371
}
494
372
 
495
373
QString Network::decodeServerString(const QByteArray &text) const {
496
 
  if(_codecForServer) return ::decodeString(text, _codecForServer);
497
 
  else return ::decodeString(text, _defaultCodecForServer);
 
374
  if(_codecForServer)
 
375
    return ::decodeString(text, _codecForServer);
 
376
  else
 
377
    return ::decodeString(text, _defaultCodecForServer);
498
378
}
499
379
 
500
380
QByteArray Network::encodeServerString(const QString &string) const {
521
401
}
522
402
 
523
403
void Network::setConnected(bool connected) {
 
404
  if(_connected == connected)
 
405
    return;
 
406
  
524
407
  _connected = connected;
525
408
  if(!connected) {
 
409
    setMyNick(QString());
 
410
    setCurrentServer(QString());
526
411
    removeChansAndUsers();
527
 
    setCurrentServer(QString());
528
412
  }
529
413
  emit connectedSet(connected);
530
414
}
539
423
 
540
424
void Network::setMyNick(const QString &nickname) {
541
425
  _myNick = nickname;
 
426
  if(!_myNick.isEmpty() && !ircUser(myNick())) {
 
427
    newIrcUser(myNick());
 
428
  }
542
429
  emit myNickSet(nickname);
543
430
}
544
431
 
626
513
  return supports;
627
514
}
628
515
 
629
 
QVariantList Network::initServerList() const {
630
 
  return serverList();
631
 
}
632
 
 
633
516
QStringList Network::initIrcUsers() const {
634
517
  QStringList hostmasks;
635
518
  foreach(IrcUser *ircuser, ircUsers()) {
656
539
  }
657
540
}
658
541
 
659
 
void Network::initSetServerList(const QVariantList & serverList) {
660
 
  setServerList(serverList);
661
 
}
662
 
 
663
542
void Network::initSetIrcUsers(const QStringList &hostmasks) {
664
543
  if(!_ircUsers.empty())
665
544
    return;
737
616
  emit ircChannelRemoved(channel);
738
617
}
739
618
 
740
 
void Network::requestConnect() const {
741
 
  if(!proxy()) return;
742
 
  if(proxy()->proxyMode() == SignalProxy::Client) emit connectRequested(); // on the client this triggers calling this slot on the core
743
 
  else {
744
 
    if(connectionState() != Disconnected) {
745
 
      qWarning() << "Requesting connect while already being connected!";
746
 
      return;
747
 
    }
748
 
    emit connectRequested(networkId());  // and this is for CoreSession :)
749
 
  }
750
 
}
751
 
 
752
 
void Network::requestDisconnect() const {
753
 
  if(!proxy()) return;
754
 
  if(proxy()->proxyMode() == SignalProxy::Client) emit disconnectRequested(); // on the client this triggers calling this slot on the core
755
 
  else {
756
 
    if(connectionState() == Disconnected) {
757
 
      qWarning() << "Requesting disconnect while not being connected!";
758
 
      return;
759
 
    }
760
 
    emit disconnectRequested(networkId());  // and this is for CoreSession :)
761
 
  }
762
 
}
763
 
 
764
619
void Network::emitConnectionError(const QString &errorMsg) {
765
620
  emit connectionError(errorMsg);
766
621
}
887
742
      << " rejoinChannels = " << i.rejoinChannels << ")";
888
743
  return dbg.space();
889
744
}
890
 
 
891
 
 
892
 
 
893