开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
udpsession.cpp
资源名称：一个类似QQ的软件源码.rar　[点击查看]
上传用户：zslianheng
上传日期：2013-04-03
资源大小：946k
文件大小：28k
源码类别：

Linux/Unix编程

开发平台：

Visual C++

udpsession.cpp：源码内容
  1. /***************************************************************************
  2.  *                                                                         *
  3.  *   This program is free software; you can redistribute it and/or modify  *
  4.  *   it under the terms of the GNU General Public License as published by  *
  5.  *   the Free Software Foundation; either version 2 of the License, or     *
  6.  *   (at your option) any later version.                                   *
  7.  *                                                                         *
  8.  *   copyright            : (C) 2002 by Zhang Yong                         *
  9.  *   email                : z-yong163@163.com                              *
  10.  ***************************************************************************/
  12. #include <stdio.h>
  13. #include <stdlib.h>
  14. #include <string.h>
  15. #include <iostream.h>
  16. #include "udppacket.h"
  17. #include "sessionhash.h"
  18. #include "ndes.h"
  20. enum {
  21. UDP_ACK = 1,
  22. UDP_NEW_UIN,
  23. UDP_GET_CONTACTLIST,
  24. UDP_LOGIN,
  25. UDP_LOGOUT,
  26. UDP_KEEPALIVE,
  27. UDP_CHANGE_STATUS,
  28. UDP_UPDATE_CONTACT,
  29. UDP_MODIFY_USER,
  30. UDP_UPDATE_USER,
  31. UDP_SEND_MSG,
  32. UDP_GROUP_SEND_MSG,
  33. UDP_SEARCH_RANDOM,
  34. UDP_SEARCH_CUSTOM,
  35. UDP_ADD_FRIEND,
  36. UDP_DEL_FRIEND,
  37. UDP_BROADCAST_MSG,
  39. UDP_SRV_USER_ONLINE = 0x0100,
  40. UDP_SRV_USER_OFFLINE,
  41. UDP_SRV_MULTI_ONLINE,
  42. UDP_SRV_STATUS_CHANGED,
  43. UDP_SRV_MESSAGE,
  44. UDP_SRV_SEARCH,
  45. };
  47. enum {
  48. LOGIN_SUCCESS,
  49. LOGIN_INVALID_UIN,
  50. LOGIN_WRONG_PASSWD,
  51. };
  53. enum {
  54. STATUS_ONLINE = 0,
  55. STATUS_OFFLINE,
  56. STATUS_AWAY,
  57. STATUS_INVIS
  58. };
  60. enum {
  61. MSG_TEXT,
  62. MSG_AUTO_REPLY,
  63. MSG_AUTH_ACCEPTED,
  64. MSG_AUTH_REQ,
  65. MSG_AUTH_REJECTED,
  66. MSG_ADDED,
  67. MSG_BROADCAST,
  68. };
  70. enum {
  71. ADD_FRIEND_ACCEPTED,
  72. ADD_FRIEND_AUTH_REQ,
  73. ADD_FRIEND_REJECTED,
  74. };
  76. #define MYICQ_UDP_VER 1
  77. #define MYICQ_PORT_DEFAULT 8000
  78. #define MAX_SEARCH_PER_PAGE 25
  79. #define MAX_SEND_ATTEMPTS 2
  80. #define MAX_SQL_STATEMENT 4096
  81. #define MAX_MSG_LEN 512
  82. #define START_UIN 1000
  84. struct BROADCAST_MSG {
  85. IcqListItem listItem;
  87. uint32 id;
  88. uint8 type;
  89. uint32 when;
  90. uint32 src;
  91. char text[MAX_MSG_LEN];
  92. uint32 to;
  93. uint32 maxUIN;
  94. time_t expire;
  95. };
  97. int UdpSession::sock = -1;
  98. IcqList UdpSession::globalSendQueue;
  99. IcqList UdpSession::keepAliveList;
  100. IcqList UdpSession::broadMsgList;
  101. MYSQL UdpSession::mysql;
  102. char UdpSession::sqlStmt[MAX_SQL_STATEMENT];
  103. uint32 UdpSession::sessionCount = 0;
  106. bool UdpSession::initialize()
  107. {
  108. srand(time(NULL));
  109. desinit(0);
  111. sock = socket(AF_INET, SOCK_DGRAM, 0);
  112. if (sock < 0) {
  113. cerr << "create socket failed." << endl;
  114. return false;
  115. }
  117. sockaddr_in addr;
  118. memset(&addr, 0, sizeof(addr));
  119. addr.sin_family = AF_INET;
  120. addr.sin_port = htons(MYICQ_PORT_DEFAULT);
  121. addr.sin_addr.s_addr = INADDR_ANY;
  122. if (bind(sock, (sockaddr *) &addr, sizeof(addr)) < 0) {
  123. cerr << "socket bind failed." << endl;
  124. close(sock);
  125. return false;
  126. }
  128. if (!mysql_init(&mysql)) {
  129. cerr << "mysql initialization failed." << endl;
  130. return false;
  131. }
  133. const char *host = LOCAL_HOST;
  134. const char *user = "myicq";
  135. const char *pass = "myicq";
  136. const char *db = "myicq";
  137. const char *unix_socket = NULL;
  139. if (!mysql_real_connect(&mysql, host, user, pass, db, 0, unix_socket, 0)) {
  140. cerr << "can not connect to mysql server." << endl;
  141. mysql_close(&mysql);
  142. return false;
  143. }
  145. return true;
  146. }
  148. void UdpSession::cleanUp()
  149. {
  150. IcqListItem *head = &keepAliveList.head;
  151. IcqListItem *pos;
  152. UdpSession *p;
  154. while ((pos = head->next) != head) {
  155. p = LIST_ENTRY(pos, UdpSession, keepAliveItem);
  156. delete p;
  157. }
  159. mysql_close(&mysql);
  160. close(sock);
  161. }
  163. bool UdpSession::onReceive()
  164. {
  165. UdpInPacket in;
  166. int n = in.recv(sock);
  167. if (n < 0)
  168. return false;
  170. if (n < (int) sizeof(UDP_HEADER)) {
  171. cout << "packet size is less than " << sizeof(UDP_HEADER) << endl;
  172. return false;
  173. }
  174. uint16 ver = in.getVersion();
  175. if (ver > MYICQ_UDP_VER) {
  176. cout << "packet v" << ver << " not supported." << endl;
  177. return false;
  178. }
  180. uint16 cmd = in.getCmd();
  181. uint32 uin = in.getUIN();
  182. uint32 ip = in.getIP();
  183. uint16 port = in.getPort();
  184. UdpSession *session = NULL;
  186. if (cmd == UDP_NEW_UIN)
  187. session = SessionHash::getDead(ip, port);
  188. else if (cmd != UDP_LOGIN) {
  189. session = SessionHash::getAlive(uin);
  190. if (!session && cmd == UDP_ACK)
  191. session = SessionHash::getDead(ip, port);
  192. if (!session)
  193. return false;
  194. }
  196. if (!session) {
  197. session = new UdpSession;
  198. if (!session) {
  199. cout << "create session failed." << endl;
  200. return false;
  201. }
  202. }
  204. session->onReceive(in);
  205. return true;
  206. }
  208. time_t UdpSession::checkSendQueue()
  209. {
  210. IcqListItem *pos;
  211. UdpOutPacket *p;
  212. UdpSession *session;
  213. IcqListItem *head = &globalSendQueue.head;
  214. time_t now = time(NULL);
  216. while ((pos = head->next) != head) {
  217. p = LIST_ENTRY(head->next, UdpOutPacket, globalSendItem);
  218. if (p->expire > now)
  219. return (p->expire - now);
  221. session = p->session;
  222. cout << "packet " << p->getSeq() << " time out." << endl;
  225. p->attempts++;
  226. if (p->attempts <= MAX_SEND_ATTEMPTS) {
  227. cout << "retrasmit packet." << endl;
  228. pos->remove();
  229. p->expire = now + SEND_TIMEOUT;
  230. session->sendDirect(p);
  231. globalSendQueue.add(pos);
  232. }
  233. else {
  234. cout << "maximum attempts reached. delete it!" << endl;
  235. p->sendItem.remove();
  236. p->globalSendItem.remove();
  237. delete p;
  238. }
  239. }
  240. return SEND_TIMEOUT;
  241. }
  243. time_t UdpSession::checkKeepAlive()
  244. {
  245. IcqListItem *pos;
  246. UdpSession *p;
  247. IcqListItem *head = &keepAliveList.head;
  248. time_t now = time(NULL);
  250. while ((pos = head->next) != head) {
  251. p = LIST_ENTRY(pos, UdpSession, keepAliveItem);
  252. if (p->expire > now)
  253. return (p->expire - now);
  255. cout << p->uin << " expires." << endl;
  256. if (p->status != STATUS_OFFLINE)
  257. p->dead();
  258. delete p;
  259. }
  260. return KEEPALIVE_TIMEOUT;
  261. }
  263. void UdpSession::broadcastMessages()
  264. {
  265. if (broadMsgList.isEmpty())
  266. return;
  268. BROADCAST_MSG *msg = LIST_ENTRY(broadMsgList.getHead(), BROADCAST_MSG, listItem);
  269. for (int i = 0; i < 10; ++i) {
  270. UdpSession *s = SessionHash::getAlive(msg->to);
  271. if (s)
  272. sendMessage(msg->type, msg->to, msg->src, s, msg->when, msg->text);
  273. else {
  274. int n = sprintf(sqlStmt, "INSERT INTO broadmsg_tbl VALUES(%lu, %lu)", msg->to, msg->id);
  275. mysql_real_query(&mysql, sqlStmt, n);
  276. }
  277. msg->to++;
  278. if (msg->to > msg->maxUIN) {
  279. msg->listItem.remove();
  280. delete msg;
  281. break;
  282. }
  283. }
  284. }
  286. void UdpSession::addFriend(uint32 dst, uint32 src, UdpSession *dstSession, UdpSession *srcSession)
  287. {
  288. int n = sprintf(sqlStmt, "INSERT INTO friend_tbl values(%lu, %lu)", src, dst);
  289. mysql_real_query(&mysql, sqlStmt, n);
  291. if (!srcSession)
  292. return;
  294. if (dstSession && dstSession->status != STATUS_INVIS) {
  295. UdpOutPacket *out = srcSession->createPacket(UDP_SRV_USER_ONLINE);
  296. out->write32(dst);
  297. out->write32(dstSession->status);
  298. out->write32(dstSession->ip);
  299. out->write16(dstSession->port);
  300. out->write32(dstSession->realIP);
  301. srcSession->sendPacket(out);
  302. }
  303. }
  305. void UdpSession::onlineNotify()
  306. {
  307. MYSQL_RES *res;
  308. MYSQL_ROW row;
  310. int n = sprintf(sqlStmt, "SELECT uin1 FROM friend_tbl WHERE uin2=%lu", uin);
  311. if (mysql_real_query(&mysql, sqlStmt, n) == 0 && (res = mysql_store_result(&mysql))) {
  312. while ((row = mysql_fetch_row(res))) {
  313. uint32 friendUIN = atol(row[0]);
  314. UdpSession *session = SessionHash::getAlive(friendUIN);
  315. if (session) {
  316. UdpOutPacket *out = session->createPacket(UDP_SRV_USER_ONLINE);
  317. out->write32(uin);
  318. out->write32(status);
  319. out->write32(ip);
  320. out->write16(port);
  321. out->write32(realIP);
  322. session->sendPacket(out);
  323. }
  324. }
  325. mysql_free_result(res);
  326. }
  327. }
  329. void UdpSession::offlineNotify()
  330. {
  331. MYSQL_RES *res;
  332. MYSQL_ROW row;
  334. int n = sprintf(sqlStmt, "SELECT uin1 FROM friend_tbl WHERE uin2=%lu", uin);
  335. if (mysql_real_query(&mysql, sqlStmt, n) == 0 && (res = mysql_store_result(&mysql))) {
  336. while ((row = mysql_fetch_row(res))) {
  337. uint32 friendUIN = atol(row[0]);
  338. UdpSession *session = SessionHash::getAlive(friendUIN);
  339. if (session) {
  340. UdpOutPacket *out = session->createPacket(UDP_SRV_USER_OFFLINE);
  341. out->write32(uin);
  342. session->sendPacket(out);
  343. }
  344. }
  345. mysql_free_result(res);
  346. }
  347. }
  349. UdpSession::UdpSession()
  350. {
  351. udpVer = 0;
  352. tcpVer = 0;
  353. sid = 0;
  354. uin = 0;
  355. auth = 0;
  356. ip = realIP = 0;
  357. port = 0;
  358. status = STATUS_OFFLINE;
  360. sendSeq = rand() & 0x7fff;
  361. recvSeq = 0;
  362. window = 0;
  363. expire = time(NULL) + KEEPALIVE_TIMEOUT;
  365. sessionCount++;
  366. }
  368. UdpSession::~UdpSession()
  369. {
  370. IcqListItem *head = &sendQueue.head;
  371. IcqListItem *pos;
  373. while ((pos = head->next) != head) {
  374. UdpOutPacket *p = LIST_ENTRY(pos, UdpOutPacket, sendItem);
  375. pos->remove();
  376. p->globalSendItem.remove();
  377. delete p;
  378. }
  380. listItem.remove();
  381. keepAliveItem.remove();
  383. sessionCount--;
  384. }
  386. UdpOutPacket *UdpSession::createPacket(uint16 cmd, uint16 ackSeq)
  387. {
  388. UdpOutPacket *out = new UdpOutPacket(this);
  389. createPacket(*out, cmd, ackSeq);
  390. return out;
  391. }
  393. void UdpSession::createPacket(UdpOutPacket &out, uint16 cmd, uint16 ackSeq)
  394. {
  395. out.write16(udpVer);
  396. out.write32(0);
  397. out.write32(sid);
  398. out.write16(++sendSeq);
  399. out.write16(ackSeq);
  400. out.write16(cmd);
  401. out.write32(uin);
  402. }
  404. void UdpSession::sendAckPacket(uint16 cmd, uint16 seq)
  405. {
  406. UdpOutPacket out(this);
  407. out.write16(udpVer);
  408. out.write32(0);
  409. out.write32(sid);
  410. out.write16(0);
  411. out.write16(seq);
  412. out.write16(cmd);
  413. out.write32(uin);
  414. sendDirect(&out);
  415. }
  417. void UdpSession::sendPacket(UdpOutPacket *p)
  418. {
  419. p->attempts = 0;
  420. p->expire = time(NULL) + SEND_TIMEOUT;
  421. sendDirect(p);
  423. sendQueue.add(&p->sendItem);
  424. globalSendQueue.add(&p->globalSendItem);
  425. }
  427. bool UdpSession::setWindow(uint16 seq)
  428. {
  429. if (seq >= recvSeq + 32 || seq < recvSeq)
  430. return false;
  432. if (seq == recvSeq) {
  433. do {
  434. recvSeq++;
  435. window >>= 1;
  436. } while (window & 0x1);
  437. } else {
  438. uint32 mask = (1 << (seq - recvSeq));
  439. if (window & mask)
  440. return false;
  441. else
  442. window |= mask;
  443. }
  444. return true;
  445. }
  447. bool UdpSession::onReceive(UdpInPacket &in)
  448. {
  449. uint16 cmd = in.getCmd();
  450. uint16 seq = in.getSeq();
  452. if (cmd != UDP_LOGIN && cmd != UDP_NEW_UIN) {
  453. if (sid != in.getSID() || uin != in.getUIN()) {
  454. cout << "packet does not belong to this session." << endl;
  455. return false;
  456. }
  457. in.decrypt(passwd);
  459. } else if (sid == 0) {
  460. udpVer = in.getVersion();
  461. ip = in.getIP();
  462. port = in.getPort();
  463. recvSeq = seq;
  464. sid = in.getSID();
  465. }
  467. if (cmd != UDP_ACK && !setWindow(seq)) {
  468. cout << "packet " << seq << " is duplicated" << endl;
  469. sendAckPacket(cmd, seq);
  470. return false;
  471. }
  473. switch (cmd) {
  474. case UDP_ACK:
  475. onAck(seq);
  476. return true;
  478. case UDP_KEEPALIVE:
  479. onKeepAlive(in);
  480. break;
  482. case UDP_NEW_UIN:
  483. onNewUIN(in);
  484. break;
  486. case UDP_GET_CONTACTLIST:
  487. onGetContactList(in);
  488. break;
  490. case UDP_LOGIN:
  491. onLogin(in);
  492. break;
  494. case UDP_LOGOUT:
  495. onLogout(in);
  496. return true;
  498. case UDP_CHANGE_STATUS:
  499. sendAckPacket(cmd, seq);
  500. onChangeStatus(in);
  501. break;
  503. case UDP_UPDATE_CONTACT:
  504. onUpdateContact(in);
  505. break;
  507. case UDP_UPDATE_USER:
  508. onUpdateUser(in);
  509. break;
  511. case UDP_MODIFY_USER:
  512. sendAckPacket(cmd, seq);
  513. onModifyUser(in);
  514. break;
  516. case UDP_SEND_MSG:
  517. sendAckPacket(cmd, seq);
  518. onSendMessage(in);
  519. break;
  521. case UDP_GROUP_SEND_MSG:
  522. sendAckPacket(cmd, seq);
  523. //onGroupSendMessage(in);
  524. break;
  526. case UDP_SEARCH_RANDOM:
  527. onSearchRandom(in);
  528. break;
  530. case UDP_SEARCH_CUSTOM:
  531. onSearchCustom(in);
  532. break;
  534. case UDP_ADD_FRIEND:
  535. onAddFriend(in);
  536. break;
  538. case UDP_DEL_FRIEND:
  539. sendAckPacket(cmd, seq);
  540. onDelFriend(in);
  541. break;
  543. case UDP_BROADCAST_MSG:
  544. sendAckPacket(cmd, seq);
  545. onBroadcastMsg(in);
  546. break;
  548. default:
  549. cerr << "unknown cmd " << cmd << endl;
  550. return false;
  551. }
  552. return true;
  553. }
  555. void UdpSession::onAck(uint16 seq)
  556. {
  557. IcqListItem *head = &sendQueue.head;
  558. IcqListItem *pos;
  559. UdpOutPacket *p;
  561. LIST_FOR_EACH(pos, head) {
  562. p = LIST_ENTRY(pos, UdpOutPacket, sendItem);
  563. if (p->getSeq() == seq) {
  564. cout << "packet " << seq << " is ACKed" << endl;
  565. pos->remove();
  566. p->globalSendItem.remove();
  567. delete p;
  568. if (status == STATUS_OFFLINE && sendQueue.isEmpty()) {
  569. cout << "session is dead!" << endl;
  570. delete this;
  571. }
  572. return;
  573. }
  574. }
  575. cout << "ACK packet(seq = " << seq << ") is ignored" << endl;
  576. }
  578. void UdpSession::onNewUIN(UdpInPacket &in)
  579. {
  580. const char *pass = in.readString();
  582. int n = sprintf(sqlStmt, "INSERT INTO basic_tbl (passwd) VALUES(password('%s'))", pass);
  583. if (mysql_real_query(&mysql, sqlStmt, n) == 0) {
  584. uin = (uint32) mysql_insert_id(&mysql);
  585. n = sprintf(sqlStmt, "INSERT INTO ext_tbl (uin) VALUES(%lu)", uin);
  586. mysql_real_query(&mysql, sqlStmt, n);
  587. }
  589. UdpOutPacket *out = createPacket(UDP_NEW_UIN, in.getSeq());
  590. out->write32(uin);
  591. sendPacket(out);
  593. keepAliveList.add(&keepAliveItem);
  594. SessionHash::addDead(this);
  595. cout << uin << " has registered." << endl;
  596. }
  598. void UdpSession::onGetContactList(UdpInPacket &in)
  599. {
  600. MYSQL_RES *res;
  601. MYSQL_ROW row;
  603. int n = sprintf(sqlStmt, "SELECT uin2 FROM friend_tbl WHERE uin1=%lu", uin);
  604. if (mysql_real_query(&mysql, sqlStmt, n) == 0 && (res = mysql_store_result(&mysql))) {
  605. uint16 num = 0;
  606. UdpOutPacket *out = createPacket(UDP_GET_CONTACTLIST, in.getSeq());
  607. char *old = out->skip(sizeof(num));
  609. while ((row = mysql_fetch_row(res))) {
  610. out->write32(atol(row[0]));
  611. num++;
  612. }
  613. mysql_free_result(res);
  615. old = out->setCursor(old);
  616. out->write16(num);
  617. out->setCursor(old);
  618. sendPacket(out);
  619. }
  620. }
  622. void UdpSession::onLogin(UdpInPacket &in)
  623. {
  624. uint8 error = LOGIN_INVALID_UIN;
  625. UdpOutPacket *out;
  626. uint32 friendUIN;
  627. MYSQL_RES *res;
  628. MYSQL_ROW row;
  630. uin = in.getUIN();
  631. const char *pass = in.readString();
  632. status = in.read32();
  633. tcpVer = in.read16();
  634. realIP = in.read32();
  636. int n = sprintf(sqlStmt, "SELECT auth FROM basic_tbl WHERE uin=%lu AND passwd=password('%s')", uin, pass);
  637. if (mysql_real_query(&mysql, sqlStmt, n) == 0 && (res = mysql_store_result(&mysql))) {
  638. row = mysql_fetch_row(res);
  639. if (row) {
  640. auth = atoi(row[0]);
  641. error = LOGIN_SUCCESS;
  642. }
  643. mysql_free_result(res);
  644. }
  646. out = createPacket(UDP_LOGIN, in.getSeq());
  647. out->write8(error);
  648. sendPacket(out);
  650. keepAliveList.add(&keepAliveItem);
  652. if (error != LOGIN_SUCCESS) {
  653. cout << uin << " login failed." << endl;
  654. SessionHash::addDead(this);
  655. return;
  656. }
  658. strncpy(passwd, pass, 8);
  659. cout << uin << " successfully logged in." << endl;
  661. UdpSession *session = SessionHash::getAlive(uin);
  662. if (session) {
  663. cout << "previous session exists, delete it." << endl;
  664. delete session;
  665. session = NULL;
  666. }
  667. SessionHash::addAlive(this);
  669. // inform me of my friends' status.
  670. n = sprintf(sqlStmt, "SELECT uin2 FROM friend_tbl WHERE uin1=%lu", uin);
  671. if (mysql_real_query(&mysql, sqlStmt, n) == 0 && (res = mysql_store_result(&mysql))) {
  672. uint16 num = 0;
  673. out = createPacket(UDP_SRV_MULTI_ONLINE);
  674. char *old = out->skip(sizeof(num));
  676. while ((row = mysql_fetch_row(res))) {
  677. friendUIN = atol(row[0]);
  678. UdpSession *session = SessionHash::getAlive(friendUIN);
  679. if (session && session->status != STATUS_INVIS) {
  680. num++;
  681. out->write32(friendUIN);
  682. out->write32(session->status);
  683. out->write32(session->ip);
  684. out->write16(session->port);
  685. out->write32(session->realIP);
  686. cout << "friend " << friendUIN << " is online" << endl;
  687. }
  688. }
  689. if (num) {
  690. old = out->setCursor(old);
  691. out->write16(num);
  692. out->setCursor(old);
  693. sendPacket(out);
  694. } else {
  695. sendSeq--;
  696. delete out;
  697. }
  699. mysql_free_result(res);
  700. }
  702. // I am now online!
  703. if (status == STATUS_OFFLINE)
  704. status = STATUS_ONLINE;
  705. if (status != STATUS_INVIS)
  706. onlineNotify();
  708. // Broadcast messages
  709. n = sprintf(sqlStmt, "SELECT src, type, time, msg FROM broadmsg_tbl a, broadmsg_content_tbl b "
  710. "WHERE dst=%lu AND a.id=b.id", uin);
  711. sendMessages(sqlStmt, n);
  713. // Has someone sent me messages during offline?
  714. n = sprintf(sqlStmt, "SELECT src, type, time, msg FROM message_tbl WHERE dst=%lu", uin);
  715. sendMessages(sqlStmt, n);
  716. }
  718. void UdpSession::sendMessages(const char *sql, int n)
  719. {
  720. MYSQL_RES *res;
  721. MYSQL_ROW row;
  723. if (mysql_real_query(&mysql, sql, n) == 0 && (res = mysql_store_result(&mysql))) {
  724. while ((row = mysql_fetch_row(res))) {
  725. uint32 friendUIN = atol(row[0]);
  726. uint8 type = atoi(row[1]);
  727. time_t sendTime = atol(row[2]);
  728. const char *text = row[3];
  730. UdpOutPacket *out = createPacket(UDP_SRV_MESSAGE);
  731. out->write8(type);
  732. out->write32(friendUIN);
  733. out->write32(sendTime);
  734. out->writeString(text);
  735. sendPacket(out);
  736. }
  737. mysql_free_result(res);
  738. }
  739. }
  741. void UdpSession::sendMessage(uint8 type, uint32 dst, uint32 src, UdpSession *dstSession, time_t when, const char *text)
  742. {
  743. if (dstSession) {
  744. UdpOutPacket *out = dstSession->createPacket(UDP_SRV_MESSAGE);
  745. out->write8(type);
  746. out->write32(src);
  747. out->write32(when);
  748. out->writeString(text);
  749. dstSession->sendPacket(out);
  750. } else {
  751. int n = sprintf(sqlStmt, "INSERT INTO message_tbl values(%lu, %lu, %d, %lu, '%s')",
  752. dst, src, (int) type, when, text);
  753. mysql_real_query(&mysql, sqlStmt, n);
  754. }
  755. }
  757. void UdpSession::onUpdateContact(UdpInPacket &in)
  758. {
  759. uint32 dst = in.read32();
  760. MYSQL_RES *res;
  761. MYSQL_ROW row;
  763. int n = sprintf(sqlStmt, "SELECT pic, nick, age, gender, country, province, city, email,"
  764. "address, zipcode, tel, name, blood, college, profession, homepage, intro "
  765. "FROM basic_tbl a, ext_tbl b WHERE a.uin=%lu AND a.uin=b.uin", dst);
  766. if (mysql_real_query(&mysql, sqlStmt, n) == 0 && (res = mysql_store_result(&mysql))) {
  767. row = mysql_fetch_row(res);
  768. if (row) {
  769. UdpOutPacket *out = createPacket(UDP_UPDATE_CONTACT, in.getSeq());
  770. out->write32(dst);
  772. out->write8(atoi(row[0]));
  773. out->writeString(row[1]);
  774. out->write8(atoi(row[2]));
  775. out->write8(atoi(row[3]));
  777. out->writeString(row[4]);
  778. out->writeString(row[5]);
  779. out->writeString(row[6]);
  781. out->writeString(row[7]);
  782. out->writeString(row[8]);
  783. out->writeString(row[9]);
  784. out->writeString(row[10]);
  786. out->writeString(row[11]);
  787. out->write8(atoi(row[12]));
  788. out->writeString(row[13]);
  789. out->writeString(row[14]);
  790. out->writeString(row[15]);
  791. out->writeString(row[16]);
  793. sendPacket(out);
  794. }
  795. mysql_free_result(res);
  796. }
  797. }
  799. void UdpSession::onUpdateUser(UdpInPacket &in)
  800. {
  801. MYSQL_RES *res;
  802. MYSQL_ROW row;
  804. int n = sprintf(sqlStmt, "SELECT pic, nick, age, gender, country, province, city, email, "
  805. "address, zipcode, tel, name, blood, college, profession, homepage, intro "
  806. "FROM basic_tbl a, ext_tbl b WHERE a.uin=%lu AND a.uin=b.uin", uin);
  807. if (mysql_real_query(&mysql, sqlStmt, n) == 0 && (res = mysql_store_result(&mysql))) {
  808. row = mysql_fetch_row(res);
  809. if (row) {
  810. UdpOutPacket *out = createPacket(UDP_UPDATE_USER, in.getSeq());
  812. out->write8(atoi(row[0]));
  813. out->writeString(row[1]);
  814. out->write8(atoi(row[2]));
  815. out->write8(atoi(row[3]));
  816. out->writeString(row[4]);
  817. out->writeString(row[5]);
  818. out->writeString(row[6]);
  820. out->writeString(row[7]);
  821. out->writeString(row[8]);
  822. out->writeString(row[9]);
  823. out->writeString(row[10]);
  825. out->writeString(row[11]);
  826. out->write8(atoi(row[12]));
  827. out->writeString(row[13]);
  828. out->writeString(row[14]);
  829. out->writeString(row[15]);
  830. out->writeString(row[16]);
  832. out->write8(auth);
  834. sendPacket(out);
  835. }
  836. mysql_free_result(res);
  837. }
  838. }
  840. void UdpSession::onModifyUser(UdpInPacket &in)
  841. {
  842. int pic = in.read8();
  843. const char *nick = in.readString();
  844. int age = in.read8();
  845. int gender = in.read8();
  846. const char *country = in.readString();
  847. const char *province = in.readString();
  848. const char *city = in.readString();
  849. const char *email = in.readString();
  850. const char *address = in.readString();
  851. const char *zipcode = in.readString();
  852. const char *tel = in.readString();
  853. const char *name = in.readString();
  854. int blood = in.read8();
  855. const char *college = in.readString();
  856. const char *profession = in.readString();
  857. const char *homepage = in.readString();
  858. const char *intro = in.readString();
  859. auth = in.read8();
  860. uint8 modifyPasswd = in.read8();
  862. char *p = sqlStmt;
  863. p += sprintf(p, "UPDATE basic_tbl SET ");
  864. if (modifyPasswd) {
  865. const char *pass = in.readString();
  866. if (*pass)
  867. p += sprintf(p, "passwd=password('%s'), ", pass);
  868. }
  869. p += sprintf(p, "nick='%s', pic=%d, gender=%d, age=%d, country='%s', province='%s', city='%s', email='%s', auth=%d "
  870. "WHERE uin=%lu", nick, pic, gender, age, country, province, city, email, auth, uin);
  871. int n = p - sqlStmt;
  872. mysql_real_query(&mysql, sqlStmt, n);
  874. n = sprintf(sqlStmt, "UPDATE ext_tbl SET "
  875. "address='%s', zipcode='%s', tel='%s', "
  876. "name='%s', blood=%d, college='%s', profession='%s', homepage='%s', intro='%s' WHERE uin=%lu",
  877. address, zipcode, tel, name, blood, college, profession, homepage, intro, uin);
  878. mysql_real_query(&mysql, sqlStmt, n);
  879. }
  881. void UdpSession::dead()
  882. {
  883. if (status != STATUS_INVIS)
  884. offlineNotify();
  885. status = STATUS_OFFLINE;
  886. }
  888. void UdpSession::onLogout(UdpInPacket &in)
  889. {
  890. cout << uin << " logged out." << endl;
  891. dead();
  893. if (sendQueue.isEmpty()) {
  894. // delete all offline messages
  895. int n = sprintf(sqlStmt, "DELETE FROM message_tbl WHERE dst=%lu", uin);
  896. mysql_real_query(&mysql, sqlStmt, n);
  898. n = sprintf(sqlStmt, "DELETE FROM broadmsg_tbl WHERE dst=%lu", uin);
  899. mysql_real_query(&mysql, sqlStmt, n);
  900. }
  901. delete this;
  902. }
  904. void UdpSession::onChangeStatus(UdpInPacket &in)
  905. {
  906. uint32 oldStatus = status;
  907. status = in.read32();
  909. if (oldStatus == STATUS_INVIS && status != STATUS_INVIS)
  910. onlineNotify();
  911. else if (oldStatus != STATUS_INVIS && status == STATUS_INVIS)
  912. offlineNotify();
  913. else if (status != STATUS_INVIS) {
  914. MYSQL_RES *res;
  915. MYSQL_ROW row;
  917. int n = sprintf(sqlStmt, "SELECT uin1 FROM friend_tbl WHERE uin2=%lu", uin);
  918. if (mysql_real_query(&mysql, sqlStmt, n) == 0 && (res = mysql_store_result(&mysql))) {
  919. while ((row = mysql_fetch_row(res))) {
  920. uint32 friendUIN = atol(row[0]);
  921. UdpSession *session = SessionHash::getAlive(friendUIN);
  922. if (session) {
  923. UdpOutPacket *out = session->createPacket(UDP_SRV_STATUS_CHANGED);
  924. out->write32(uin);
  925. out->write32(status);
  926. session->sendPacket(out);
  927. }
  928. }
  929. mysql_free_result(res);
  930. }
  931. }
  932. }
  934. void UdpSession::onKeepAlive(UdpInPacket &in)
  935. {
  936. cout << uin << " keeps alive" << endl;
  938. expire = time(NULL) + KEEPALIVE_TIMEOUT;
  939. keepAliveItem.remove();
  940. keepAliveList.add(&keepAliveItem);
  942. UdpOutPacket out(this);
  943. createPacket(out, UDP_KEEPALIVE, in.getSeq());
  944. out.write32(sessionCount);
  945. sendDirect(&out);
  946. }
  948. void UdpSession::onSendMessage(UdpInPacket &in)
  949. {
  950. uint8 type = in.read8();
  951. uint32 to = in.read32();
  952. time_t when = in.read32();
  953. const char *text = in.readString();
  955. UdpSession *session = SessionHash::getAlive(to);
  956. sendMessage(type, to, uin, session, when, text);
  958. if (type == MSG_AUTH_ACCEPTED)
  959. addFriend(uin, to, this, session);
  960. }
  962. void UdpSession::onBroadcastMsg(UdpInPacket &in)
  963. {
  964. if (uin >= START_UIN)
  965. return;
  967. uint8 type = in.read8();
  968. uint32 when = in.read32();
  969. time_t expire = in.read32();
  970. const char *text = in.readString();
  972. if (expire <= time(NULL) || !*text)
  973. return;
  975. int n = sprintf(sqlStmt, "INSERT INTO broadmsg_content_tbl "
  976. "VALUES(NULL, %lu, %d, %lu, %lu, '%s')", uin, type, when, expire, text);
  977. mysql_real_query(&mysql, sqlStmt, n);
  979. BROADCAST_MSG *msg = new BROADCAST_MSG;
  980. msg->id = (uint32) mysql_insert_id(&mysql);
  981. msg->type = type;
  982. msg->src = uin;
  983. msg->when = when;
  984. strncpy(msg->text, text, MAX_MSG_LEN);
  985. msg->expire = expire;
  986. msg->to = START_UIN;
  988. MYSQL_RES *res;
  989. MYSQL_ROW row;
  990. static const char sql[] = "SELECT MAX(uin) FROM basic_tbl";
  991. if (mysql_real_query(&mysql, sql, sizeof(sql) - 1) == 0 && (res = mysql_store_result(&mysql))) {
  992. row = mysql_fetch_row(res);
  993. if (row)
  994. msg->maxUIN = atoi(row[0]);
  995. mysql_free_result(res);
  996. }
  998. broadMsgList.add(&msg->listItem);
  999. }
  1001. void UdpSession::onGroupSendMessage(UdpInPacket &in)
  1002. {
  1003. uint8 type = in.read8();
  1004. time_t when = in.read32();
  1005. const char *text = in.readString();
  1007. int n = in.read16();
  1008. while (n-- > 0) {
  1009. uint32 to = in.read32();
  1010. UdpSession *session = SessionHash::getAlive(to);
  1011. sendMessage(type, to, uin, session, when, text);
  1012. }
  1013. }
  1015. void UdpSession::onSearchRandom(UdpInPacket &in)
  1016. {
  1017. uint32 results[MAX_SEARCH_PER_PAGE];
  1018. uint16 n = SessionHash::random(results, MAX_SEARCH_PER_PAGE);
  1019. UdpOutPacket *out = createPacket(UDP_SRV_SEARCH, in.getSeq());
  1020. out->write16(n);
  1022. if (n > 0) {
  1023. MYSQL_RES *res;
  1024. MYSQL_ROW row;
  1026. static const char sql[] = "SELECT uin, pic, nick, province FROM basic_tbl WHERE uin IN(";
  1027. memcpy(sqlStmt, sql, sizeof(sql));
  1028. char *p = sqlStmt + sizeof(sql) - 1;
  1029. for (int i = 0; i < n; i++)
  1030. p += sprintf(p, "%lu,", results[i]);
  1031. *(p - 1) = ')';
  1033. if (mysql_real_query(&mysql, sqlStmt, p - sqlStmt) == 0 &&
  1034. (res = mysql_store_result(&mysql))) {
  1035. while ((row = mysql_fetch_row(res))) {
  1036. uint32 contactUIN = atoi(row[0]);
  1037. uint8 pic = atoi(row[1]);
  1038. const char *nick = row[2];
  1039. const char *province = row[3];
  1041. out->write32(contactUIN);
  1042. out->write8(1); // online
  1043. out->write8(pic);
  1044. out->writeString(nick);
  1045. out->writeString(province);
  1046. }
  1047. mysql_free_result(res);
  1048. }
  1049. }
  1051. sendPacket(out);
  1052. }
  1054. void UdpSession::onSearchCustom(UdpInPacket &in)
  1055. {
  1056. uint32 uin = in.read32();
  1057. const char *nick = in.readString();
  1058. const char *email = in.readString();
  1059. uint32 startUIN = in.read32();
  1060. int n;
  1062. if (uin != 0) {
  1063. n = sprintf(sqlStmt, "SELECT uin, pic, nick, province FROM basic_tbl WHERE uin=%lu LIMIT %d",
  1064. uin, MAX_SEARCH_PER_PAGE);
  1065. } else if (*nick || *email) {
  1066. char *p = sqlStmt;
  1067. p += sprintf(p, "SELECT uin, pic, nick, province FROM basic_tbl WHERE uin>%lu AND ", startUIN);
  1069. if (*nick)
  1070. p += sprintf(p, "nick='%s'", nick);
  1071. if (*email) {
  1072. if (*nick)
  1073. p += sprintf(p, " AND ");
  1074. p += sprintf(p, "email='%s'", email);
  1075. }
  1076. p += sprintf(p, " LIMIT %d", MAX_SEARCH_PER_PAGE);
  1077. n = p - sqlStmt;
  1078. } else {
  1079. cout << "unknown search mode" << endl;
  1080. return;
  1081. }
  1083. MYSQL_RES *res;
  1084. MYSQL_ROW row;
  1085. UdpOutPacket *out;
  1087. if (mysql_real_query(&mysql, sqlStmt, n) == 0 && (res = mysql_store_result(&mysql))) {
  1089. uint16 num = 0;
  1090. out = createPacket(UDP_SRV_SEARCH, in.getSeq());
  1091. char *old = out->skip(sizeof(num));
  1093. while ((row = mysql_fetch_row(res))) {
  1094. uint32 contactUIN = atoi(row[0]);
  1095. uint8 pic = atoi(row[1]);
  1096. const char *nick = row[2];
  1097. const char *province = row[3];
  1099. out->write32(contactUIN);
  1100. out->write8(SessionHash::getAlive(contactUIN) ? 1 : 0);
  1101. out->write8(pic);
  1102. out->writeString(nick);
  1103. out->writeString(province);
  1105. num++;
  1106. }
  1107. mysql_free_result(res);
  1109. old = out->setCursor(old);
  1110. out->write16(num);
  1111. out->setCursor(old);
  1112. sendPacket(out);
  1113. }
  1114. }
  1116. void UdpSession::onAddFriend(UdpInPacket &in)
  1117. {
  1118. uint32 dst = in.read32();
  1119. uint8 dstAuth = 0;
  1121. UdpSession *dstSession = SessionHash::getAlive(dst);
  1122. if (dstSession)
  1123. dstAuth = dstSession->auth;
  1124. else {
  1125. MYSQL_RES *res;
  1126. MYSQL_ROW row;
  1127. int n = sprintf(sqlStmt, "SELECT auth FROM basic_tbl WHERE uin=%lu", dst);
  1128. if (mysql_real_query(&mysql, sqlStmt, n) == 0 && (res = mysql_store_result(&mysql))) {
  1129. row = mysql_fetch_row(res);
  1130. if (row)
  1131. dstAuth = atoi(row[0]);
  1132. mysql_free_result(res);
  1133. }
  1134. }
  1136. UdpOutPacket *out = createPacket(UDP_ADD_FRIEND, in.getSeq());
  1137. out->write32(dst);
  1138. out->write8(dstAuth);
  1139. sendPacket(out);
  1141. if (dstAuth == ADD_FRIEND_ACCEPTED) {
  1142. addFriend(dst, uin, dstSession, this);
  1143. sendMessage(MSG_ADDED, dst, uin, dstSession, time(NULL), "");
  1144. }
  1145. }
  1147. void UdpSession::onDelFriend(UdpInPacket &in)
  1148. {
  1149. uint32 dst = in.read32();
  1151. int n = sprintf(sqlStmt, "DELETE FROM friend_tbl WHERE uin1=%lu AND uin2=%lu", uin, dst);
  1152. mysql_real_query(&mysql, sqlStmt, n);
  1153. }