API tools faq
paste
Guest User

Untitled

a guest
Jul 13th, 2018
74
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 42.51 KB | None | 0 0
raw download clone embed print report
  1. #include "socket.h"
  2. #include "irc/replycodes.h"
  3. #include "irc/rfc2812.h"
  4. #include <KDateTime>
  5. #include <KDebug>
  6. #include <QSslSocket>
  7. #include <QStringList>
  8. #include <QTextCodec>
  9. #include <QTimer>
  10. using namespace Aki::Irc;
  11.  
  12. namespace Aki
  13. {
  14. namespace Irc
  15. {
  16. class SocketPrivate
  17. {
  18. public:
  19. SocketPrivate(Aki::Irc::Socket *qq)
  20. : q(qq),
  21. socket(0),
  22. name("Default"),
  23. data(QString()),
  24. realName(QString()),
  25. identName("akiirc"),
  26. serviceName(QString()),
  27. servicePassword(QString()),
  28. currentAddress(QString()),
  29. codec(QTextCodec::codecForName("UTF-8")),
  30. queueTimer(0),
  31. autoReconnection(false),
  32. ssl(false),
  33. selfDisconnection(false),
  34. autoIdentify(false),
  35. connected(false),
  36. retryAttempts(10),
  37. retryInterval(10)
  38. {
  39. addressList.clear();
  40. channelList.clear();
  41. nickList.clear();
  42. }
  43.  
  44. void readyRead()
  45. {
  46. data += codec->toUnicode(socket->readAll());
  47. bool isFinished = data.right(2) != "\r\n" ? false : true;
  48.  
  49. QStringList lines = data.split("\r\n", QString::SkipEmptyParts);
  50.  
  51. if (isFinished) {
  52. data.clear();
  53. } else {
  54. data = lines.last();
  55. lines.removeLast();
  56. }
  57.  
  58. QStringListIterator msgIter(lines);
  59. while (msgIter.hasNext()) {
  60. processData(msgIter.next());
  61. }
  62. }
  63.  
  64. void updateQueue()
  65. {
  66. }
  67.  
  68. void error(QAbstractSocket::SocketError error)
  69. {
  70. switch (error) {
  71. case QAbstractSocket::ConnectionRefusedError:
  72. case QAbstractSocket::RemoteHostClosedError:
  73. case QAbstractSocket::HostNotFoundError:
  74. case QAbstractSocket::SocketAccessError:
  75. case QAbstractSocket::SocketResourceError:
  76. case QAbstractSocket::SocketTimeoutError:
  77. case QAbstractSocket::NetworkError:
  78. case QAbstractSocket::UnsupportedSocketOperationError:
  79. case QAbstractSocket::UnfinishedSocketOperationError:
  80. case QAbstractSocket::ProxyAuthenticationRequiredError:
  81. case QAbstractSocket::SslHandshakeFailedError:
  82. case QAbstractSocket::ProxyConnectionRefusedError:
  83. case QAbstractSocket::ProxyConnectionClosedError:
  84. case QAbstractSocket::ProxyConnectionTimeoutError:
  85. case QAbstractSocket::ProxyNotFoundError:
  86. case QAbstractSocket::ProxyProtocolError:
  87. /*case KTcpSocket::ConnectionRefusedError:
  88. case KTcpSocket::HostNotFoundError:
  89. case KTcpSocket::NetworkError:
  90. case KTcpSocket::RemoteHostClosedError:
  91. case KTcpSocket::SocketAccessError:
  92. case KTcpSocket::SocketResourceError:
  93. case KTcpSocket::SocketTimeoutError:
  94. case KTcpSocket::UnknownError:
  95. case KTcpSocket::UnsupportedSocketOperationError:*/
  96. if (q->isAutoReconnectionEnabled()) {
  97. QTimer::singleShot(q->retryInterval(), q, SLOT(connectToHost()));
  98. //emit q->updateRetryAttemptCount();
  99. }
  100. break;
  101. default: {
  102. break;
  103. }
  104. }
  105.  
  106. emit q->error(error);
  107. }
  108.  
  109. void stateChanged(QAbstractSocket::SocketState state)
  110. {
  111. switch (state) {
  112. case QAbstractSocket::UnconnectedState:
  113. case QAbstractSocket::HostLookupState:
  114. case QAbstractSocket::ConnectingState:
  115. case QAbstractSocket::ClosingState:
  116. /*case KTcpSocket::ConnectingState:
  117. case KTcpSocket::HostLookupState:
  118. case KTcpSocket::UnconnectedState:
  119. case KTcpSocket::ClosingState:*/ {
  120. queueTimer->stop();
  121. connected = false;
  122. break;
  123. }
  124. case QAbstractSocket::ConnectedState: {
  125. //case KTcpSocket::ConnectedState: {
  126. queueTimer->start();
  127. q->rfcUser(q->identName(), false, q->realName());
  128. q->rfcNick(q->currentNick());
  129. connected = true;
  130. break;
  131. }
  132. default: {
  133. break;
  134. }
  135. }
  136.  
  137. emit q->stateChanged(state);
  138. }
  139.  
  140. void sslErrors(const QList<QSslError> &errors)
  141. {
  142. Q_UNUSED(errors);
  143. }
  144.  
  145. void write(const QString &data)
  146. {
  147. socket->write(codec->fromUnicode(data));
  148. }
  149.  
  150. void processData(const QString &data)
  151. {
  152. QString line = data;
  153. QString server;
  154. QString prefix;
  155. QString command;
  156. QStringList params;
  157. bool isNumeric = false;
  158.  
  159. #ifdef IRC_DEBUG_OUTPUT
  160. kDebug() << data;
  161. #endif
  162.  
  163. if (line.startsWith(QChar(':'))) {
  164. prefix = line.mid(1, line.indexOf(QChar(' ')) - 1);
  165. line.remove(0, prefix.length() + 2);
  166. }
  167.  
  168. command = line.left(line.indexOf(QChar(' ')));
  169. line.remove(0, command.length() + 1);
  170.  
  171. quint16 code = command.toUShort(&isNumeric);
  172.  
  173. while (!line.isEmpty()) {
  174. if (line.startsWith(QChar(':'))) {
  175. line.remove(0, 1);
  176. params << line;
  177. line.clear();
  178. } else {
  179. QString param = line.left(line.indexOf(QChar(' ')));
  180. line.remove(0, param.length() + 1);
  181. params << param;
  182. }
  183. }
  184.  
  185. #ifndef IRC_DEBUG_OUTPUT
  186. if (isNumeric) {
  187. kDebug() << code << ' ' << params;
  188. } else {
  189. kDebug() << command << ' ' << params;
  190. }
  191. #endif
  192.  
  193. if (command == "JOIN") {
  194. QString nick = Aki::Irc::Rfc2812::nickFromMask(prefix);
  195. if (nick == q->currentNick()) {
  196. emit q->onSelfJoin(params.value(0));
  197. } else {
  198. emit q->onUserJoin(prefix, params.value(0));
  199. }
  200. } else if (command == "PART") {
  201. if (params.count() == 1) {
  202. emit q->onUserPart(prefix, params.value(0));
  203. } else {
  204. emit q->onUserPart(prefix, params.value(0), params.value(1));
  205. }
  206. } else if (command == "INVITE") {
  207. QString from = Aki::Irc::Rfc2812::nickFromMask(prefix);
  208.  
  209. if (params.value(0) == q->currentNick()) {
  210. emit q->onInvite(from, params.value(1));
  211. }
  212. } else if (command == "PRIVMSG") {
  213.  
  214. } else if (command == "NOTICE") {
  215. if (params.value(0) == "AUTH") {
  216. emit q->onNoticeAuth(params.value(1));
  217. } else if (params.value(1).startsWith(QChar('\1')) &&
  218. params.value(1).endsWith(QChar('\1'))) {
  219. params.value(1).remove(0, 1);
  220. params.value(1).remove(params.value(1).length() - 1, 1);
  221.  
  222. QString type = params.value(1).left(params.value(1).indexOf(QChar(' ')));
  223. if (type == "VERSION") {
  224. QString from = Aki::Irc::Rfc2812::nickFromMask(prefix);
  225. emit q->onNoticeCtcpVersion(from, params.value(1));
  226. }
  227. }
  228. } else if (command == "KICK") {
  229. emit q->onKick(params.value(0), params.value(1), params.value(2));
  230. } else if (command == "NICK") {
  231. QString oldNick = Aki::Irc::Rfc2812::nickFromMask(prefix);
  232. emit q->onNick(oldNick, params.value(0));
  233. } else if (command == "QUIT") {
  234. if (params.count() == 0) {
  235. emit q->onUserQuit(prefix);
  236. } else {
  237. emit q->onUserQuit(prefix, params.value(0));
  238. }
  239. } else if (command == "PING") {
  240. q->rfcPong(params.value(0));
  241. } else if (command == "PONG") {
  242. emit q->onPong(params.value(1));
  243. } else if (command == "MODE") {
  244. QString from = Aki::Irc::Rfc2812::nickFromMask(prefix);
  245.  
  246. if (Aki::Irc::Rfc2812::isValidNickname(from)) {
  247. if (from == q->currentNick()) {
  248. if (params.value(0) == q->currentNick()) {
  249. emit q->onSelfUMode(params.value(1));
  250. } else if (Aki::Irc::Rfc2812::isValidChannel(params.value(0))) {
  251. if (params.count() == 3 && Aki::Irc::Rfc2812::isValidNickname(params.value(2))) {
  252. emit q->onMode(from, params.value(0), params.value(1), params.value(2));
  253. } else {
  254. QStringList modes;
  255.  
  256. if (params.count() >= 2) {
  257. for (int i = 2; i < params.count(); ++i) {
  258. modes << params.value(i);
  259. }
  260. emit q->onMode(from, params.value(0), params.value(1), params.value(2));
  261. }
  262. }
  263. }
  264. } else {
  265. if (Aki::Irc::Rfc2812::isValidChannel(params.value(0))) {
  266. emit q->onMode(from, params.value(0), params.value(1), params.value(2));
  267. }
  268. }
  269. } else {
  270. if (params.value(0) == q->currentNick()) {
  271. emit q->onUMode(from, params.value(1));
  272. } else if (Aki::Irc::Rfc2812::isValidChannel(params.value(0))) {
  273. QStringList modes;
  274.  
  275. if (params.count() >= 2) {
  276. for (int i = 2; i < params.count(); ++i) {
  277. modes << params.value(i);
  278. }
  279. }
  280.  
  281. emit q->onMode(from, params.value(0), params.value(1), modes);
  282. }
  283. }
  284. } else if (command == "TOPIC") {
  285. QString from = Aki::Irc::Rfc2812::nickFromMask(prefix);
  286. emit q->onTopicChanged(from, params.value(0), params.value(1));
  287. } else if (isNumeric) {
  288. switch (code) {
  289. case RPL_WELCOME: {
  290. emit q->onWelcome(params.at(1));
  291. break;
  292. }
  293. case RPL_YOURHOST: {
  294. emit q->onYourHost(params.at(1));
  295. break;
  296. }
  297. case RPL_CREATED: {
  298. emit q->onCreated(params.at(1));
  299. break;
  300. }
  301. case RPL_MYINFO: {
  302. QString tmp;
  303. for (int i = 0; i < params.count(); ++i) {
  304. tmp.append(params.at(i) + QChar(' '));
  305. }
  306. tmp.remove(tmp.length() - 1, 1);
  307. emit q->onMyInfo(tmp);
  308. break;
  309. }
  310. case RPL_ISUPPORT: {
  311. QString tmp;
  312. for (int i = 0; i < params.count(); ++i) {
  313. tmp.append(params.at(i) + QChar(' '));
  314. }
  315. tmp.remove(tmp.length() - 1, 1);
  316. emit q->onISupport(tmp);
  317. break;
  318. }
  319. case RPL_TRACELINK:
  320. case RPL_TRACECONNECTING:
  321. case RPL_TRACEHANDSHAKE:
  322. case RPL_TRACEUNKNOWN:
  323. case RPL_TRACEOPERATOR:
  324. case RPL_TRACEUSER:
  325. case RPL_TRACESERVER:
  326. case RPL_TRACENEWTYPE:
  327. case RPL_TRACECLASS:
  328. case RPL_TRACERECONNECT:
  329. case RPL_STATSLINKINFO:
  330. case RPL_STATSCOMMANDS:
  331. case RPL_STATSCLINE:
  332. case RPL_STATSNLINE:
  333. case RPL_STATSILINE:
  334. case RPL_STATSKLINE:
  335. case RPL_STATSYLINE:
  336. case RPL_ENDOFSTATS:
  337. break;
  338. case RPL_UMODEIS: {
  339. emit q->onUModeIs(params.at(1));
  340. break;
  341. }
  342. case RPL_HIGHCONNECTCOUNT: {
  343. emit q->onHighConnectCount(params.at(1));
  344. break;
  345. }
  346. case RPL_LUSERCLIENT: {
  347. emit q->onLUserClient(params.at(1));
  348. break;
  349. }
  350. case RPL_LUSEROP: {
  351. emit q->onLUserOp(params.at(1).toInt(), params.at(2));
  352. break;
  353. }
  354. case RPL_LUSERUNKNOWN: {
  355. emit q->onLUserUnknown(params.at(1).toInt(), params.at(2));
  356. break;
  357. }
  358. case RPL_LUSERCHANNELS: {
  359. emit q->onLUserChannels(params.at(1).toInt(), params.at(2));
  360. break;
  361. }
  362. case RPL_LUSERME: {
  363. emit q->onLUserMe(params.at(1));
  364. break;
  365. }
  366. case RPL_ADMINME:
  367. case RPL_ADMINLOC1:
  368. case RPL_ADMINLOC2:
  369. case RPL_ADMINEMAIL:
  370. case RPL_TRACELOG:
  371. case RPL_TRACEEND:
  372. case RPL_LOCALUSERS: {
  373. emit q->onLocalUsers(params.at(1));
  374. break;
  375. }
  376. case RPL_GLOBALUSERS: {
  377. emit q->onGlobalUsers(params.at(1));
  378. break;
  379. }
  380. case RPL_CAPAB:
  381. case RPL_NONE:
  382. break;
  383. case RPL_AWAY: {
  384. emit q->onAway(params.at(1), params.at(2));
  385. break;
  386. }
  387. case RPL_USERHOST:
  388. case RPL_ISON:
  389. break;
  390. case RPL_UNAWAY: {
  391. emit q->onUnAway(params.at(1));
  392. break;
  393. }
  394. case RPL_NOWAWAY: {
  395. emit q->onNowAway(params.at(1));
  396. break;
  397. }
  398. case RPL_WHOISIDENTIFY:
  399. case RPL_WHOISHELPER:
  400. break;
  401. case RPL_WHOISUSER: {
  402. emit q->onWhoIsUser(params.at(1), params.at(2), params.at(3), params.at(5));
  403. break;
  404. }
  405. case RPL_WHOISSERVER: {
  406. emit q->onWhoIsServer(params.at(1), params.at(2), params.at(3));
  407. break;
  408. }
  409. case RPL_WHOISOPERATOR:
  410. break;
  411. case RPL_WHOWASUSER: {
  412. emit q->onWhoWasUser(params.at(1), params.at(2), params.at(3), params.at(5));
  413. break;
  414. }
  415. case RPL_ENDOFWHO: {
  416. emit q->onEndOfWho(params.at(1), params.at(2));
  417. break;
  418. }
  419. case RPL_WHOISIDLE:
  420. case RPL_ENDOFWHOIS:
  421. break;
  422. case RPL_WHOISCHANNELS: {
  423. emit q->onWhoIsChannels(params.at(1), params.at(2));
  424. break;
  425. }
  426. case RPL_IDENTIFIED: {
  427. emit q->onWhoIsIdentified(params.at(1), params.at(2));
  428. break;
  429. }
  430. case RPL_LISTSTART:
  431. case RPL_LIST:
  432. case RPL_LISTEND:
  433. break;
  434. case RPL_CHANNELMODEIS: {
  435. QStringList modes;
  436.  
  437. if (params.count() > 2) {
  438. for (int i = 3; i < params.count(); ++i) {
  439. modes << params.at(i);
  440. }
  441. }
  442.  
  443. emit q->onChannelModeIs(params.at(1), params.at(2), modes);
  444. break;
  445. }
  446. case RPL_UNIQOPIS:
  447. break;
  448. case RPL_CHANNELURLIS: {
  449. emit q->onChannelUrlIs(params.at(1), params.at(2));
  450. break;
  451. }
  452. case RPL_CHANNELCREATED: {
  453. KDateTime time;
  454. time.setTime_t(params.at(2).toUInt());
  455. time = time.toClockTime();
  456. emit q->onChannelCreated(params.at(1), time.toString("%B %d %Y %H:%M:%S"));
  457. break;
  458. }
  459. case RPL_WHOSISACCOUNT:
  460. break;
  461. case RPL_NOTOPIC: {
  462. emit q->onNoTopic(params.at(1), params.at(2));
  463. break;
  464. }
  465. case RPL_TOPIC: {
  466. emit q->onTopic(params.at(1), params.at(2));
  467. break;
  468. }
  469. case RPL_TOPICSETBY: {
  470. KDateTime time;
  471. time.setTime_t(params.at(3).toUInt());
  472. time = time.toClockTime();
  473. emit q->onTopicSetBy(params.at(2), params.at(1), time.toString("%B %d %Y %H:%M:%S"));
  474. break;
  475. }
  476. case RPL_WHOISACTUALLY:
  477. break;
  478. case RPL_INVITING: {
  479. emit q->onInviting(params.at(1), params.at(2));
  480. break;
  481. }
  482. case RPL_SUMMONING:
  483. case RPL_INVITELIST:
  484. case RPL_ENDOFEXCEPTLIST:
  485. case RPL_VERSION: {
  486. QString version;
  487. for (int i = 1; i < params.count(); ++i) {
  488. if (i == params.count()) {
  489. version.append(params.at(i));
  490. } else {
  491. version.append(params.at(i) + QChar(' '));
  492. }
  493. }
  494. emit q->onVersion(version);
  495. break;
  496. }
  497. case RPL_WHOREPLY: {
  498. QString param7 = params.at(7);
  499. QString tmp = param7.left(param7.indexOf(QChar(' ')));
  500. param7.remove(0, tmp.length() + 1);
  501. emit q->onWho(params.at(1), params.at(2), params.at(3), params.at(4), params.at(5),
  502. params.at(6), tmp.toInt(), param7);
  503. break;
  504. }
  505. case RPL_NAMREPLY: {
  506. emit q->onNameReply(params.at(2), params.at(3));
  507. break;
  508. }
  509. case RPL_TRYAGAIN:
  510. case RPL_LINKS:
  511. case RPL_ENDOFLINKS:
  512. case RPL_ENDOFNAMES: {
  513. emit q->onEndOfNames(params.at(1), params.at(2));
  514. break;
  515. }
  516. case RPL_BANLIST: {
  517. KDateTime time;
  518. time.setTime_t(params.at(4).toUInt());
  519. time = time.toClockTime();
  520. emit q->onBanList(params.at(1), params.at(2), params.at(3),
  521. time.toString("%m-%d-%Y %H:%M:%S"));
  522. break;
  523. }
  524. case RPL_ENDOFBANLIST: {
  525. emit q->onEndOfBanList(params.at(1), params.at(2));
  526. break;
  527. }
  528. case RPL_ENDOFWHOWAS: {
  529. emit q->onEndOfWhoWas(params.at(1), params.at(2));
  530. break;
  531. }
  532. case RPL_INFO:
  533. case RPL_MOTD: {
  534. emit q->onMotd(params.at(1));
  535. break;
  536. }
  537. case RPL_ENDOFINFO:
  538. break;
  539. case RPL_MOTDSTART: {
  540. emit q->onMotdStart(params.at(1));
  541. break;
  542. }
  543. case RPL_ENDOFMOTD: {
  544. emit q->onEndOfMotd(params.at(1));
  545. break;
  546. }
  547. case RPL_YOUREOPER:
  548. case RPL_REHASHING:
  549. case RPL_YOURESERVICE:
  550. break;
  551. case RPL_TIME: {
  552. emit q->onTime(params.at(1), params.at(2));
  553. break;
  554. }
  555. case RPL_USERSSTART:
  556. case RPL_USERS:
  557. case RPL_ENDOFUSERS:
  558. case RPL_NOUSERS:
  559. break;
  560. case ERR_NOSUCHNICK: {
  561. emit q->onErrorNoSuchNick(params.at(1), params.at(2));
  562. break;
  563. }
  564. case ERR_NOSUCHSERVER: {
  565. emit q->onErrorNoSuchServer(params.at(1), params.at(2));
  566. break;
  567. }
  568. case ERR_NOSUCHCHANNEL: {
  569. emit q->onErrorNoSuchChannel(params.at(1), params.at(2));
  570. break;
  571. }
  572. case ERR_CANNOTSENDTOCHAN: {
  573. emit q->onErrorCannotSendToChannel(params.at(1), params.at(2));
  574. break;
  575. }
  576. case ERR_TOOMANYCHANNELS: {
  577. emit q->onErrorTooManyChannels(params.at(1), params.at(2));
  578. break;
  579. }
  580. case ERR_WASNOSUCHNICK: {
  581. emit q->onErrorWasNoSuchNick(params.at(1), params.at(2));
  582. break;
  583. }
  584. case ERR_TOOMANYTARGETS:
  585. break;
  586. case ERR_NOSUCHSERVICE: {
  587. emit q->onErrorNoSuchService(params.at(1), params.at(2));
  588. break;
  589. }
  590. case ERR_NORECIPIENT: {
  591. emit q->onErrorNoRecipient(params.at(1));
  592. break;
  593. }
  594. case ERR_NOTEXTTOSEND: {
  595. emit q->onErrorNoTextToSend(params.at(1));
  596. break;
  597. }
  598. case ERR_NOTOPLEVEL: {
  599. emit q->onErrorNoTopLevel(params.at(1), params.at(2));
  600. break;
  601. }
  602. case ERR_WILDTOPLEVEL: {
  603. emit q->onErrorWildTopLevel(params.at(1), params.at(2));
  604. break;
  605. }
  606. case ERR_BADMASK: {
  607. break;
  608. }
  609. case ERR_UNKNOWNCOMMAND: {
  610. emit q->onErrorUnknownCommand(params.at(1), params.at(2));
  611. break;
  612. }
  613. case ERR_NOMOTD: {
  614. emit q->onErrorNoMotd(params.at(1));
  615. break;
  616. }
  617. case ERR_NOADMININFO: {
  618. emit q->onErrorNoAdminInfo(params.at(1), params.at(2));
  619. break;
  620. }
  621. case ERR_FILEERROR: {
  622. emit q->onErrorFileError(params.at(1));
  623. break;
  624. }
  625. case ERR_NONICKNAMEGIVEN: {
  626. emit q->onErrorNoNicknameGiven(params.at(1));
  627. break;
  628. }
  629. case ERR_ERRONEUSNICKNAME: {
  630. emit q->onErrorErroneusNickname(params.at(1), params.at(2));
  631. break;
  632. }
  633. case ERR_NICKNAMEINUSE: {
  634. emit q->onErrorNicknameInUse(params.at(1), params.at(2));
  635. break;
  636. }
  637. case ERR_NICKCOLLISION: {
  638. emit q->onErrorNickCollision(params.at(1), params.at(2));
  639. break;
  640. }
  641. case ERR_UNAVAILRESOURCE:
  642. case ERR_USERNOTINCHANNEL:
  643. break;
  644. case ERR_NOTONCHANNEL: {
  645. emit q->onErrorNotOnChannel(params.at(1), params.at(2));
  646. break;
  647. }
  648. case ERR_USERONCHANNEL: {
  649. emit q->onErrorUserOnChannel(params.at(1), params.at(2), params.at(3));
  650. break;
  651. }
  652. case ERR_NOLOGIN: {
  653. emit q->onErrorNoLogin(params.at(1), params.at(2));
  654. break;
  655. }
  656. case ERR_SUMMONDISABLED:
  657. case ERR_USERSDISABLED:
  658. case ERR_NOTREGISTERED:
  659. case ERR_NEEDMOREPARAMS:
  660. case ERR_ALREADYREGISTERED:
  661. case ERR_NOPERMFOROST:
  662. case ERR_PASSWDMISMATCH:
  663. break;
  664. case ERR_YOUREBANNEDCREEP: {
  665. emit q->onErrorYoureBannedCreep(params.at(1));
  666. break;
  667. }
  668. case ERR_YOUWILLBEBANNED:
  669. break;
  670. case ERR_KEYSET: {
  671. emit q->onErrorKeySet(params.at(1), params.at(2));
  672. break;
  673. }
  674. case ERR_CHANNELISFULL: {
  675. emit q->onErrorChannelIsFull(params.at(1), params.at(2));
  676. break;
  677. }
  678. case ERR_UNKNOWNMODE: {
  679. emit q->onErrorUnknownMode(params.at(1), params.at(2));
  680. break;
  681. }
  682. case ERR_INVITEONLYCHAN: {
  683. emit q->onErrorInviteOnlyChannel(params.at(1), params.at(2));
  684. break;
  685. }
  686. case ERR_BANNEDFROMCHAN: {
  687. emit q->onErrorBannedFromChannel(params.at(1), params.at(2));
  688. break;
  689. }
  690. case ERR_BADCHANNELKEY: {
  691. emit q->onErrorBadChannelKey(params.at(1), params.at(2));
  692. break;
  693. }
  694. case ERR_BADCHANMASK: {
  695. emit q->onErrorBadChanMask(params.at(1), params.at(2));
  696. break;
  697. }
  698. case ERR_NOCHANMODES: {
  699. emit q->onErrorNoChanModes(params.at(1), params.at(2));
  700. break;
  701. }
  702. case ERR_BANLISTFULL: {
  703. emit q->onErrorBanListFull(params.at(1), params.at(2), params.at(3));
  704. break;
  705. }
  706. case ERR_NOPRIVILEGES: {
  707. emit q->onErrorNoPrivileges(params.at(1));
  708. break;
  709. }
  710. case ERR_CHANOPRIVSNEEDED: {
  711. emit q->onErrorChannelPrivilegesNeeded(params.at(1), params.at(2));
  712. break;
  713. }
  714. case ERR_CANTKILLSERVER:
  715. case ERR_RESTRICTED:
  716. case ERR_UNIQOPPRIVSNEEDED:
  717. case ERR_NOOPERHOST:
  718. break;
  719. case ERR_UMODEUNKNOWNFLAG: {
  720. emit q->onErrorUModeUnknownFlag(params.at(1));
  721. break;
  722. }
  723. case ERR_USERSDONTMATCH: {
  724. emit q->onErrorUsersDontMatch(params.at(1));
  725. break;
  726. }
  727. default: {
  728. break;
  729. }
  730. }
  731. }
  732. }
  733.  
  734. Aki::Irc::Socket *q;
  735. QSslSocket *socket;
  736. QStringList addressList;
  737. QStringList channelList;
  738. QStringList nickList;
  739. QString name;
  740. QString data;
  741. QString realName;
  742. QString identName;
  743. QString serviceName;
  744. QString servicePassword;
  745. QString currentAddress;
  746. QTextCodec *codec;
  747. QTimer *queueTimer;
  748. bool autoReconnection;
  749. bool ssl;
  750. bool selfDisconnection;
  751. bool autoIdentify;
  752. bool connected;
  753. quint16 currentPort;
  754. int retryAttempts;
  755. int retryInterval;
  756. static int addressListIndex;
  757. }; // End of class SocketPrivate.
  758. } // End of namespace Irc.
  759. } // End of namespace Aki.
  760.  
  761. int Aki::Irc::SocketPrivate::addressListIndex = 0;
  762.  
  763. Socket::Socket(QObject *parent)
  764. : QObject(parent),
  765. d(new SocketPrivate(this))
  766. {
  767. d->socket = new QSslSocket(this);
  768. d->queueTimer = new QTimer(this);
  769. d->queueTimer->setInterval(500);
  770.  
  771. connect(d->socket, SIGNAL(readyRead()),
  772. SLOT(readyRead()));
  773. connect(d->queueTimer, SIGNAL(timeout()),
  774. SLOT(updateQueue()));
  775. //connect(d->socket, SIGNAL(sslErrors(QList<KSslError>)),
  776. // SLOT(sslErrors(QList<KSslError>)));
  777. //connect(d->socket, SIGNAL(stateChanged(State)),
  778. // SLOT(stateChanged(KTcpSocket::State)));
  779. //connect(d->socket, SIGNAL(error(KTcpSocket::Error)),
  780. //SLOT(error(KTcpSocket::Error)));
  781. }
  782.  
  783. Socket::Socket(const QString &name, QObject *parent)
  784. : QObject(parent),
  785. d(new SocketPrivate(this))
  786. {
  787. d->socket = new QSslSocket(this);
  788. d->name = name;
  789. d->queueTimer = new QTimer(this);
  790. d->queueTimer->setInterval(500);
  791.  
  792. connect(d->socket, SIGNAL(readyRead()),
  793. this, SLOT(readyRead()));
  794. connect(d->queueTimer, SIGNAL(timeout()),
  795. this, SLOT(updateQueue()));
  796. connect(d->socket, SIGNAL(sslErrors(QList<QSslError>)),
  797. SLOT(sslErrors(QList<QSslError>)));
  798. connect(d->socket, SIGNAL(stateChanged(QAbstractSocket::SocketState)),
  799. SLOT(stateChanged(QAbstractSocket::SocketState)));
  800. connect(d->socket, SIGNAL(error(QAbstractSocket::SocketError)),
  801. SLOT(error(QAbstractSocket::SocketError)));
  802. }
  803.  
  804. Socket::~Socket()
  805. {
  806. delete d;
  807. }
  808.  
  809. QStringList
  810. Socket::addressList() const
  811. {
  812. return d->addressList;
  813. }
  814.  
  815. void
  816. Socket::setAddressList(const QStringList &addressList)
  817. {
  818. d->addressList = addressList;
  819. }
  820.  
  821. void
  822. Socket::appendNick(const QString &nick)
  823. {
  824. if (!d->nickList.contains(nick)) {
  825. d->nickList.append(nick);
  826. setCurrentNick(nick);
  827. }
  828. }
  829.  
  830. void
  831. Socket::setCurrentNick(const QString &nick)
  832. {
  833. const int index = d->nickList.indexOf(nick);
  834. if (index >= 0) {
  835. //
  836. }
  837. }
  838.  
  839. bool
  840. Socket::isConnected() const
  841. {
  842. return d->connected;
  843. }
  844.  
  845. QString
  846. Socket::currentAddress() const
  847. {
  848. return d->currentAddress;
  849. }
  850.  
  851. quint16
  852. Socket::currentPort() const
  853. {
  854. return d->currentPort;
  855. }
  856.  
  857. QString
  858. Socket::currentNick() const
  859. {
  860. return d->nickList[0];
  861. }
  862.  
  863. bool
  864. Socket::isAutoIdentifyEnabled() const
  865. {
  866. return d->autoIdentify;
  867. }
  868.  
  869. bool
  870. Socket::isAutoReconnectionEnabled() const
  871. {
  872. return d->autoReconnection;
  873. }
  874.  
  875. QStringList
  876. Socket::channelList() const
  877. {
  878. return d->channelList;
  879. }
  880.  
  881. void
  882. Socket::setChannelList(const QStringList &channels)
  883. {
  884. d->channelList = channels;
  885. }
  886.  
  887. QString
  888. Socket::identName() const
  889. {
  890. return d->identName;
  891. }
  892.  
  893. void
  894. Socket::setIdentName(const QString &ident)
  895. {
  896. d->identName = ident;
  897. }
  898.  
  899. QString
  900. Socket::name() const
  901. {
  902. return d->name;
  903. }
  904.  
  905. void
  906. Socket::setName(const QString &name)
  907. {
  908. d->name = name;
  909. }
  910.  
  911. void
  912. Socket::setNickList(const QStringList &nicks)
  913. {
  914. d->nickList = nicks;
  915. }
  916.  
  917. QStringList
  918. Socket::nickList() const
  919. {
  920. return d->nickList;
  921. }
  922.  
  923. void
  924. Socket::setRealName(const QString &name)
  925. {
  926. d->realName = name;
  927. }
  928.  
  929. QString
  930. Socket::realName() const
  931. {
  932. return d->realName;
  933. }
  934.  
  935. int
  936. Socket::retryInterval() const
  937. {
  938. return d->retryInterval;
  939. }
  940.  
  941. int
  942. Socket::retryAttemptCount() const
  943. {
  944. return d->retryAttempts;
  945. }
  946.  
  947. void
  948. Socket::setRetryInterval(int seconds)
  949. {
  950. d->retryInterval = seconds;
  951. }
  952.  
  953. void
  954. Socket::setRetryAttemptCount(int count)
  955. {
  956. d->retryAttempts = count;
  957. }
  958.  
  959. void
  960. Socket::rfcAdmin(const QString &target)
  961. {
  962. if (target.isEmpty()) {
  963. rfcRaw("ADMIN");
  964. } else {
  965. rfcRaw(QString("ADMIN %1").arg(target));
  966. }
  967. }
  968.  
  969. void
  970. Socket::rfcAway(const QString &message)
  971. {
  972. if (message.isEmpty()) {
  973. rfcRaw("AWAY");
  974. } else {
  975. rfcRaw(QString("AWAY :%1").arg(message));
  976. }
  977. }
  978.  
  979. void
  980. Socket::rfcConnect(const QString &targetServer, const QString &port, const QString &remoteServer)
  981. {
  982. if (remoteServer.isEmpty()) {
  983. rfcRaw(QString("CONNECT %1 %2").arg(targetServer, port));
  984. } else {
  985. rfcRaw(QString("CONNECT %1 %2 %3").arg(targetServer, port, remoteServer));
  986. }
  987. }
  988.  
  989. void
  990. Socket::rfcCtcpAction(const QString &target, const QString &message)
  991. {
  992. rfcPrivmsg(target, QString("\x01" "ACTION %1\x01").arg(message));
  993. }
  994.  
  995. void
  996. Socket::rfcDie()
  997. {
  998. rfcRaw("DIE");
  999. }
  1000.  
  1001. void
  1002. Socket::rfcError(const QString &message)
  1003. {
  1004. rfcRaw(QString("ERROR :%1").arg(message));
  1005. }
  1006.  
  1007. void
  1008. Socket::rfcInfo(const QString &target)
  1009. {
  1010. if (target.isEmpty()) {
  1011. rfcRaw("INFO");
  1012. } else {
  1013. rfcRaw(QString("INFO %1").arg(target));
  1014. }
  1015. }
  1016.  
  1017. void
  1018. Socket::rfcInvite(const QString &nick, const QString &channel)
  1019. {
  1020. rfcRaw(QString("INVITE %1 %2").arg(nick, channel));
  1021. }
  1022.  
  1023. void
  1024. Socket::rfcIson(const QString &nick)
  1025. {
  1026. rfcRaw(QString("ISON %1").arg(nick));
  1027. }
  1028.  
  1029. void
  1030. Socket::rfcIson(const QStringList &nicks)
  1031. {
  1032. QString nickList = nicks.join(QChar(','));
  1033. rfcIson(nickList);
  1034. }
  1035.  
  1036. void
  1037. Socket::rfcJoin(const QString &channel, const QString &key)
  1038. {
  1039. if (key.isEmpty()) {
  1040. rfcRaw(QString("JOIN %1").arg(channel));
  1041. } else {
  1042. rfcRaw(QString("JOIN %1 %2").arg(channel, key));
  1043. }
  1044. }
  1045.  
  1046. void
  1047. Socket::rfcJoin(const QStringList &channels, const QStringList &keys)
  1048. {
  1049. QString channelList = channels.join(QChar(','));
  1050. if (keys.isEmpty()) {
  1051. rfcJoin(channelList);
  1052. } else {
  1053. QString keyList = keys.join(QChar(','));
  1054. rfcJoin(channelList, keyList);
  1055. }
  1056. }
  1057.  
  1058. void
  1059. Socket::rfcKick(const QString &channel, const QString &nick, const QString &comment)
  1060. {
  1061. if (comment.isEmpty()) {
  1062. rfcRaw(QString("KICK %1 %2").arg(channel, nick));
  1063. } else {
  1064. rfcRaw(QString("KICK %1 %2 :%3").arg(channel, nick, comment));
  1065. }
  1066. }
  1067.  
  1068. void
  1069. Socket::rfcKick(const QStringList &channels, const QString &nick, const QString &comment)
  1070. {
  1071. QString channelList = channels.join(QChar(','));
  1072. rfcKick(channelList, nick, comment);
  1073. }
  1074.  
  1075. void
  1076. Socket::rfcKick(const QString &channel, const QStringList &nicks, const QString &comment)
  1077. {
  1078. QString nickList = nicks.join(QChar(','));
  1079. rfcKick(channel, nickList, comment);
  1080. }
  1081.  
  1082. void
  1083. Socket::rfcKick(const QStringList &channels, const QStringList &nicks, const QString &comment)
  1084. {
  1085. QString channelList = channels.join(QChar(','));
  1086. QString nickList = nicks.join(QChar(','));
  1087. rfcKick(channelList, nickList, comment);
  1088. }
  1089.  
  1090. void
  1091. Socket::rfcLinks(const QString &remoteServer, const QString &serverMask)
  1092. {
  1093. if (remoteServer.isEmpty() && serverMask.isEmpty()) {
  1094. rfcRaw("LINKS");
  1095. } else if (serverMask.isEmpty()) {
  1096. rfcRaw(QString("LINKS %1").arg(remoteServer));
  1097. } else {
  1098. rfcRaw(QString("LINKS %1 %2").arg(remoteServer, serverMask));
  1099. }
  1100. }
  1101.  
  1102. void
  1103. Socket::rfcList(const QString &channel, const QString &target)
  1104. {
  1105. if (channel.isEmpty() && target.isEmpty()) {
  1106. rfcRaw("LIST");
  1107. } else if (target.isEmpty()) {
  1108. rfcRaw(QString("LIST %1").arg(channel));
  1109. } else {
  1110. rfcRaw(QString("LIST %1 %2").arg(channel, target));
  1111. }
  1112. }
  1113.  
  1114. void
  1115. Socket::rfcList(const QStringList &channels, const QString &target)
  1116. {
  1117. QString channelList = channels.join(QChar(','));
  1118. rfcList(channelList, target);
  1119. }
  1120.  
  1121. void
  1122. Socket::rfcLUsers(const QString &mask, const QString &target)
  1123. {
  1124. if (mask.isEmpty() && target.isEmpty()) {
  1125. rfcRaw("LUSERS");
  1126. } else if (target.isEmpty()) {
  1127. rfcRaw(QString("LUSERS %1").arg(mask));
  1128. } else {
  1129. rfcRaw(QString("LUSERS %1 %2").arg(mask, target));
  1130. }
  1131. }
  1132.  
  1133. void
  1134. Socket::rfcMode(const QString &target, const QString &mode)
  1135. {
  1136. if (mode.isEmpty()) {
  1137. rfcRaw(QString("MODE %1").arg(target));
  1138. } else {
  1139. rfcRaw(QString("MODE %1 %2").arg(target, mode));
  1140. }
  1141. }
  1142.  
  1143. void
  1144. Socket::rfcMotd(const QString &target)
  1145. {
  1146. if (target.isEmpty()) {
  1147. rfcRaw("MOTD");
  1148. } else {
  1149. rfcRaw(QString("MOTD %1").arg(target));
  1150. }
  1151. }
  1152.  
  1153. void
  1154. Socket::rfcNames()
  1155. {
  1156. rfcRaw("NAMES");
  1157. }
  1158.  
  1159. void
  1160. Socket::rfcNames(const QString &channel, const QString &target)
  1161. {
  1162. if (target.isEmpty()) {
  1163. rfcRaw(QString("NAMES %1").arg(channel));
  1164. } else {
  1165. rfcRaw(QString("NAMES %1 %2").arg(channel, target));
  1166. }
  1167. }
  1168.  
  1169. void
  1170. Socket::rfcNames(const QStringList &channels, const QString &target)
  1171. {
  1172. QString channelList = channels.join(QChar(','));
  1173. rfcNames(channelList, target);
  1174. }
  1175.  
  1176. void
  1177. Socket::rfcNick(const QString &nick)
  1178. {
  1179. rfcRaw(QString("NICK %1").arg(nick));
  1180. }
  1181.  
  1182. void
  1183. Socket::rfcNotice(const QString &destination, const QString &message)
  1184. {
  1185. rfcRaw(QString("NOTICE %1 :%2").arg(destination, message));
  1186. }
  1187.  
  1188. void
  1189. Socket::rfcOper(const QString &name, const QString &password)
  1190. {
  1191. rfcRaw(QString("OPER %1 %2").arg(name, password));
  1192. }
  1193.  
  1194. void
  1195. Socket::rfcPart(const QString &channel, const QString &message)
  1196. {
  1197. if (message.isEmpty()) {
  1198. rfcRaw(QString("PART %1").arg(channel));
  1199. } else {
  1200. rfcRaw(QString("PART %1 :%2").arg(channel, message));
  1201. }
  1202. }
  1203.  
  1204. void
  1205. Socket::rfcPart(const QStringList &channels, const QString &message)
  1206. {
  1207. QString channelList = channels.join(QChar(','));
  1208. if (message.isEmpty()) {
  1209. rfcPart(channelList);
  1210. } else {
  1211. rfcPart(channelList, message);
  1212. }
  1213. }
  1214.  
  1215. void
  1216. Socket::rfcPass(const QString &password)
  1217. {
  1218. rfcRaw(QString("PASS %1").arg(password));
  1219. }
  1220.  
  1221. void
  1222. Socket::rfcPing(const QString &server, const QString &server2)
  1223. {
  1224. if (server2.isEmpty()) {
  1225. rfcRaw(QString("PING %1").arg(server));
  1226. } else {
  1227. rfcRaw(QString("PING %1 %2").arg(server, server2));
  1228. }
  1229. }
  1230.  
  1231. void
  1232. Socket::rfcPong(const QString &server, const QString &server2)
  1233. {
  1234. if (server2.isEmpty()) {
  1235. rfcRaw(QString("PONG %1").arg(server));
  1236. } else {
  1237. rfcRaw(QString("PONG %1 %2").arg(server, server2));
  1238. }
  1239. }
  1240.  
  1241. void
  1242. Socket::rfcPrivmsg(const QString &destination, const QString &message)
  1243. {
  1244. rfcRaw(QString("PRIVMSG %1 :%2").arg(destination, message));
  1245. }
  1246.  
  1247. void
  1248. Socket::rfcQuit(const QString &message)
  1249. {
  1250. if (message.isEmpty()) {
  1251. rfcRaw("QUIT");
  1252. } else {
  1253. rfcRaw(QString("QUIT :%1").arg(message));
  1254. }
  1255. }
  1256.  
  1257. void
  1258. Socket::rfcRaw(const QString &command)
  1259. {
  1260. const QString type = command.left(command.indexOf(' '));
  1261. d->socket->write(codec()->fromUnicode(command + "\r\n"));
  1262. /*if (type == "WHO" || type == "MODE") {
  1263. d->queue.append(QPair<Socket::QueueType, QString>(Socket::Lowest, message));
  1264. } else if (type == "PRIVMSG" || type == "NOTICE") {
  1265. d->queue.append(QPair<Socket::QueueType, QString>(Socket::Low, message));
  1266. } else {
  1267. d->queue.append(QPair<Socket::QueueType, QString>(Socket::Normal, message));
  1268. }*/
  1269. }
  1270.  
  1271. void
  1272. Socket::rfcReHash()
  1273. {
  1274. rfcRaw("REHASH");
  1275. }
  1276.  
  1277. void
  1278. Socket::rfcRestart()
  1279. {
  1280. rfcRaw("RESTART");
  1281. }
  1282.  
  1283. void
  1284. Socket::rfcService(const QString &nick, const QString &distribution, const QString &info)
  1285. {
  1286. rfcRaw(QString("SERVICE %1 * %2 0 0 :%3").arg(nick, distribution, info));
  1287. }
  1288.  
  1289. void
  1290. Socket::rfcServList(const QString &mask, const QString &type)
  1291. {
  1292. if (mask.isEmpty() && type.isEmpty()) {
  1293. rfcRaw("SERVLIST");
  1294. } else if (type.isEmpty()) {
  1295. rfcRaw(QString("SERVLIST %1").arg(mask));
  1296. } else {
  1297. rfcRaw(QString("SERVLIST %1 %2").arg(mask, type));
  1298. }
  1299. }
  1300.  
  1301. void
  1302. Socket::rfcStats(const QString &query, const QString &target)
  1303. {
  1304. if (query.isEmpty() && target.isEmpty()) {
  1305. rfcRaw("STATS");
  1306. } else if (target.isEmpty()) {
  1307. rfcRaw(QString("STATS %1").arg(query));
  1308. } else {
  1309. rfcRaw(QString("STATS %1 %2").arg(query, target));
  1310. }
  1311. }
  1312.  
  1313. void
  1314. Socket::rfcSQuit(const QString &server, const QString &comment)
  1315. {
  1316. rfcRaw(QString("SQUIT %1 :%2").arg(server, comment));
  1317. }
  1318.  
  1319. void
  1320. Socket::rfcSummon(const QString &user, const QString &target, const QString &channel)
  1321. {
  1322. if (target.isEmpty() && channel.isEmpty()) {
  1323. rfcRaw(QString("SUMMON %1").arg(user));
  1324. } else if (channel.isEmpty()) {
  1325. rfcRaw(QString("SUMMON %1 %2").arg(user, target));
  1326. } else {
  1327. rfcRaw(QString("SUMMON %1 %2 %3").arg(user, target, channel));
  1328. }
  1329. }
  1330.  
  1331. void
  1332. Socket::rfcTime(const QString &target)
  1333. {
  1334. if (target.isEmpty()) {
  1335. rfcRaw("TIME");
  1336. } else {
  1337. rfcRaw(QString("TIME %1").arg(target));
  1338. }
  1339. }
  1340.  
  1341. void
  1342. Socket::rfcTopic(const QString &channel, const QString &topic)
  1343. {
  1344. if (topic.isEmpty() && topic.isNull()) {
  1345. rfcRaw(QString("TOPIC %1").arg(channel));
  1346. } else if (topic.isEmpty() && !topic.isNull()) {
  1347. rfcRaw(QString("TOPIC %1 : ").arg(channel));
  1348. } else {
  1349. rfcRaw(QString("TOPIC %1 :%2").arg(channel, topic));
  1350. }
  1351. }
  1352.  
  1353. void
  1354. Socket::rfcTrace(const QString &target)
  1355. {
  1356. if (target.isEmpty()) {
  1357. rfcRaw("TRACE");
  1358. } else {
  1359. rfcRaw(QString("TRACE %1").arg(target));
  1360. }
  1361. }
  1362.  
  1363. void
  1364. Socket::rfcUser(const QString &identity, bool isInvisible, const QString &realName)
  1365. {
  1366. rfcRaw(QString("USER %1 %2 * :%3").arg(identity, isInvisible ? "8" : "0", realName));
  1367. }
  1368.  
  1369. void
  1370. Socket::rfcUserHost(const QString &nick)
  1371. {
  1372. rfcRaw(QString("USERHOST %1").arg(nick));
  1373. }
  1374.  
  1375. void
  1376. Socket::rfcUserHost(const QStringList &nicks)
  1377. {
  1378. QString nickList = nicks.join(QChar(','));
  1379. rfcRaw(nickList);
  1380. }
  1381.  
  1382. void
  1383. Socket::rfcUsers(const QString &target)
  1384. {
  1385. if (target.isEmpty()) {
  1386. rfcRaw("USERS");
  1387. } else {
  1388. rfcRaw(QString("USERS %1").arg(target));
  1389. }
  1390. }
  1391.  
  1392. void
  1393. Socket::rfcVersion(const QString &target)
  1394. {
  1395. if (target.isEmpty()) {
  1396. rfcRaw("VERSION");
  1397. } else {
  1398. rfcRaw(QString("VERSION %1").arg(target));
  1399. }
  1400. }
  1401.  
  1402. void
  1403. Socket::rfcWallOps(const QString &text)
  1404. {
  1405. rfcRaw(QString("WALLOPS %1").arg(text));
  1406. }
  1407.  
  1408. void
  1409. Socket::rfcWho(const QString &mask, bool ircOp)
  1410. {
  1411. if (mask.isEmpty() && !ircOp) {
  1412. rfcRaw("WHO\r\n");
  1413. } else if (!ircOp) {
  1414. rfcRaw(QString("WHO %1").arg(mask));
  1415. } else {
  1416. rfcRaw(QString("WHO %1 o").arg(mask));
  1417. }
  1418. }
  1419.  
  1420. void
  1421. Socket::rfcWhoIs(const QString &mask)
  1422. {
  1423. rfcRaw(QString("WHOIS %1").arg(mask));
  1424. }
  1425.  
  1426. void
  1427. Socket::rfcWhoIs(const QStringList &masks)
  1428. {
  1429. QString maskList = masks.join(QChar(','));
  1430. rfcWhoIs(maskList);
  1431. }
  1432.  
  1433. void
  1434. Socket::rfcWhoIs(const QString &target, const QString &mask)
  1435. {
  1436. rfcRaw(QString("WHOIS %1 %2").arg(target, mask));
  1437. }
  1438.  
  1439. void
  1440. Socket::rfcWhoWas(const QString &nick, const QString &count, const QString &target)
  1441. {
  1442. if (count.isEmpty() && target.isEmpty()) {
  1443. rfcRaw(QString("WHOWAS %1").arg(nick));
  1444. } else if (target.isEmpty()) {
  1445. rfcRaw(QString("WHOWAS %1 %2").arg(nick, count));
  1446. } else {
  1447. rfcRaw(QString("WHOWAS %1 %2 %3").arg(nick, count, target));
  1448. }
  1449. }
  1450.  
  1451. void
  1452. Socket::rfcWhoIs(const QString &target, const QStringList &masks)
  1453. {
  1454. QString maskList = masks.join(QChar(','));
  1455. rfcWhoIs(target, maskList);
  1456. }
  1457.  
  1458. void
  1459. Socket::rfcWhoWas(const QStringList &nicks, const QString &count, const QString &target)
  1460. {
  1461. QString nickList = nicks.join(QChar(','));
  1462. rfcWhoWas(nickList, count, target);
  1463. }
  1464.  
  1465. QTextCodec*
  1466. Socket::codec()
  1467. {
  1468. return d->codec;
  1469. }
  1470.  
  1471. void
  1472. Socket::connectToHost()
  1473. {
  1474. if (addressList()[d->addressListIndex].contains('/')) {
  1475. QStringList tmp = addressList()[d->addressListIndex].split('/');
  1476. d->currentAddress = tmp[0];
  1477. d->currentPort = tmp[1].toUShort();
  1478. } else {
  1479. d->currentAddress = addressList()[d->addressListIndex];
  1480. d->currentPort = 6667;
  1481. }
  1482.  
  1483. connectToHost(currentAddress(), currentPort());
  1484. }
  1485.  
  1486. void
  1487. Socket::connectToHost(const QString &address, quint16 port)
  1488. {
  1489. if (isSslEnabled()) {
  1490. kDebug() << "Connecting via SSL";
  1491. d->socket->connectToHostEncrypted(address, port);
  1492. } else {
  1493. kDebug() << "Connecting via Normal";
  1494. d->socket->connectToHost(address, port);
  1495. }
  1496. }
  1497.  
  1498. void
  1499. Socket::setAutoIdentify(bool enable)
  1500. {
  1501. d->autoIdentify = enable;
  1502. }
  1503.  
  1504. void
  1505. Socket::setAutoReconnect(bool enable)
  1506. {
  1507. d->autoReconnection = enable;
  1508. }
  1509.  
  1510. void
  1511. Socket::setEncoding(const QByteArray &name)
  1512. {
  1513. d->codec = QTextCodec::codecForName(name);
  1514. }
  1515.  
  1516. void
  1517. Socket::setServiceName(const QString &name)
  1518. {
  1519. d->serviceName = name;
  1520. }
  1521.  
  1522. void
  1523. Socket::setServicePassword(const QString &password)
  1524. {
  1525. d->servicePassword = password;
  1526. }
  1527.  
  1528. void
  1529. Socket::setSsl(bool enable)
  1530. {
  1531. d->ssl = enable;
  1532. }
  1533.  
  1534. bool
  1535. Socket::isSslEnabled() const
  1536. {
  1537. return d->ssl;
  1538. }
  1539.  
  1540. #include "socket.moc"
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!