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

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

Linux/Unix编程

开发平台：

Visual C++

icqdb.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 "icqdb.h"
  13. #include "icqclient.h"
  15. #define INDEX_USER 0
  16. #define INDEX_OPTIONS 0xffffffff
  17. #define INDEX_GROUP 0xfffffffe
  19. string IcqDB::dbDir;
  22. DBOutStream &DBOutStream::operator <<(uint8 b)
  23. {
  24. if (cursor <= data + MAX_BLOCK_SIZE - sizeof(b))
  25. *cursor++ = b;
  26. return (*this);
  27. }
  29. DBOutStream &DBOutStream::operator <<(uint16 w)
  30. {
  31. if (cursor <= data + MAX_BLOCK_SIZE - sizeof(w)) {
  32. *(uint16 *) cursor = w;
  33. cursor += sizeof(w);
  34. }
  35. return (*this);
  36. }
  38. DBOutStream &DBOutStream::operator <<(uint32 dw)
  39. {
  40. if (cursor <= data + MAX_BLOCK_SIZE - sizeof(dw)) {
  41. *(uint32 *) cursor = dw;
  42. cursor += sizeof(dw);
  43. }
  44. return (*this);
  45. }
  47. DBOutStream &DBOutStream::operator <<(const char *str)
  48. {
  49. uint16 len = strlen(str) + 1;
  50. if (cursor <= data + MAX_BLOCK_SIZE - sizeof(len) - len) {
  51. *this << len;
  52. memcpy(cursor, str, len);
  53. cursor += len;
  54. }
  55. return (*this);
  56. }
  58. DBOutStream &DBOutStream::operator <<(StrList &strList)
  59. {
  60. uint16 n = 0;
  61. char *old = cursor;
  62. cursor += sizeof(n);
  64. StrList::iterator i;
  65. for (i = strList.begin(); i != strList.end(); i++) {
  66. operator <<(*i);
  67. n++;
  68. }
  69. char *p = cursor;
  70. cursor = old;
  71. operator <<(n);
  72. cursor = p;
  73. return (*this);
  74. }
  76. DBInStream &DBInStream::operator >>(uint8 &b)
  77. {
  78. if (cursor <= data + datalen - sizeof(b))
  79. b = *cursor++;
  80. else
  81. b = 0;
  82. return (*this);
  83. }
  85. DBInStream &DBInStream::operator >>(uint16 &w)
  86. {
  87. if (cursor <= data + datalen - sizeof(w)) {
  88. w = *(uint16 *) cursor;
  89. cursor += sizeof(w);
  90. } else
  91. w = 0;
  92. return (*this);
  93. }
  95. DBInStream &DBInStream::operator >>(uint32 &dw)
  96. {
  97. if (cursor <= data + datalen - sizeof(dw)) {
  98. dw = *(uint32 *) cursor;
  99. cursor += sizeof(dw);
  100. } else
  101. dw = 0;
  102. return (*this);
  103. }
  105. DBInStream &DBInStream::operator >>(string &str)
  106. {
  107. uint16 len;
  108. operator >>(len);
  110. if (cursor <= data + datalen - len && !cursor[len - 1]) {
  111. str = cursor;
  112. cursor += len;
  113. } else
  114. str = "";
  115. return (*this);
  116. }
  118. DBInStream &DBInStream::operator >>(StrList &strList)
  119. {
  120. uint16 num;
  121. operator >>(num);
  122. int n = (int) num;
  124. strList.clear();
  125. while (n-- > 0) {
  126. string s;
  127. operator >>(s);
  128. strList.push_back(s);
  129. }
  130. return (*this);
  131. }
  134. static const char userFile[] = "user.db";
  135. static const char msgFile[] = "msg.db";
  136. static const char quickReplyFile[] = "quickreply.txt";
  137. static const char autoReplyFile[] = "autoreply.txt";
  139. DB *IcqDB::getDBFullPath(const char *pathName, bool dup)
  140. {
  141. DB *db;
  142. if (db_create(&db, NULL, 0) != 0)
  143. return NULL;
  145. if (dup && db->set_flags(db, DB_DUP) != 0) {
  146. db->close(db, 0);
  147. return NULL;
  148. }
  149. if (db->open(db, pathName, NULL, DB_HASH, DB_CREATE, 0600) != 0) {
  150. db->close(db, 0);
  151. return NULL;
  152. }
  153. return db;
  154. }
  156. bool IcqDB::saveBlock(DB *db, uint32 index, DBSerialize &obj)
  157. {
  158. DBOutStream out;
  159. obj.save(out);
  161. DBT key, data;
  162. memset(&key, 0, sizeof(key));
  163. memset(&data, 0, sizeof(data));
  164. key.data = &index;
  165. key.size = sizeof(index);
  166. data.data = out.getData();
  167. data.size = out.getSize();
  169. return (db->put(db, NULL, &key, &data, 0) == 0);
  170. }
  172. bool IcqDB::saveBlock(const char *fileName, uint32 index, DBSerialize &obj, bool dup)
  173. {
  174. DB *db = getDB(fileName, dup);
  175. if (!db)
  176. return false;
  178. int ret = saveBlock(db, index, obj);
  179. db->close(db, 0);
  180. return (ret == 0);
  181. }
  183. bool IcqDB::loadBlock(const char *fileName, uint32 index, DBSerialize &obj)
  184. {
  185. DB *db = getDB(fileName, false);
  186. if (!db)
  187. return false;
  189. DBT key, data;
  190. memset(&key, 0, sizeof(key));
  191. memset(&data, 0, sizeof(data));
  192. key.data = &index;
  193. key.size = sizeof(index);
  195. if (db->get(db, NULL, &key, &data, 0) != 0) {
  196. db->close(db, 0);
  197. return false;
  198. }
  200. DBInStream in(data.data, data.size);
  201. obj.load(in);
  203. db->close(db, 0);
  204. return true;
  205. }
  207. bool IcqDB::delIndex(const char *fileName, uint32 index)
  208. {
  209. DB *db = getDB(fileName);
  210. if (!db)
  211. return false;
  213. DBT key;
  214. memset(&key, 0, sizeof(key));
  215. key.data = &index;
  216. key.size = sizeof(index);
  217. int ret = db->del(db, NULL, &key, 0);
  219. db->close(db, 0);
  220. return (ret == 0);
  221. }
  223. bool IcqDB::saveMsg(IcqMsg &msg)
  224. {
  225. uint32 uin = (msg.isSysMsg() ? 0 : msg.uin);
  226. return saveBlock(msgFile, uin, msg, true);
  227. }
  229. bool IcqDB::delMsg(uint32 uin)
  230. {
  231. return delIndex(msgFile, uin);
  232. }
  234. bool IcqDB::delMsg(uint32 uin, int item)
  235. {
  236. DB *db = getDB(msgFile);
  237. if (!db)
  238. return false;
  240. DBC *cursor;
  241. if (db->cursor(db, NULL, &cursor, 0) != 0) {
  242. db->close(db, 0);
  243. return false;
  244. }
  246. DBT key, data;
  247. memset(&key, 0, sizeof(key));
  248. memset(&data, 0, sizeof(data));
  249. key.data = &uin;
  250. key.size = sizeof(uin);
  251. if (cursor->c_get(cursor, &key, &data, DB_SET) != 0) {
  252. db->close(db, 0);
  253. return false;
  254. }
  256. for (int i = 0; i < item; ++i) {
  257. if (cursor->c_get(cursor, &key, &data, DB_NEXT_DUP) != 0)
  258. break;
  259. }
  260. if (i < item) {
  261. cursor->c_close(cursor);
  262. db->close(db, 0);
  263. return false;
  264. }
  266. int ret = cursor->c_del(cursor, 0);
  268. cursor->c_close(cursor);
  269. db->close(db, 0);
  270. return (ret == 0);
  271. }
  273. bool IcqDB::loadMsg(uint32 uin, PtrList &msgList)
  274. {
  275. DB *db = getDB(msgFile, true);
  276. if (!db)
  277. return false;
  279. DBC *cursor;
  280. if (db->cursor(db, NULL, &cursor, 0) != 0) {
  281. db->close(db, 0);
  282. return false;
  283. }
  285. DBT key, data;
  286. memset(&key, 0, sizeof(key));
  287. memset(&data, 0, sizeof(data));
  288. key.data = &uin;
  289. key.size = sizeof(uin);
  291. if (cursor->c_get(cursor, &key, &data, DB_SET) != 0) {
  292. cursor->c_close(cursor);
  293. db->close(db, 0);
  294. return false;
  295. }
  297. do {
  298. DBInStream in(data.data, data.size);
  299. IcqMsg *msg = new IcqMsg;
  300. msg->load(in);
  301. msgList.push_back(msg);
  303. } while (cursor->c_get(cursor, &key, &data, DB_NEXT_DUP) == 0);
  305. cursor->c_close(cursor);
  306. db->close(db, 0);
  307. return true;
  308. }
  310. bool IcqDB::saveContact(IcqContact &c)
  311. {
  312. return saveBlock(userFile, c.uin, c, false);
  313. }
  315. bool IcqDB::loadContact(IcqContact &c)
  316. {
  317. return loadBlock(userFile, c.uin, c);
  318. }
  320. bool IcqDB::loadContact(PtrList &contactList)
  321. {
  322. DB *db = getDB(userFile);
  323. if (!db)
  324. return false;
  326. DBC *cursor;
  327. if (db->cursor(db, NULL, &cursor, 0) != 0) {
  328. db->close(db, 0);
  329. return false;
  330. }
  332. DBT key, data;
  333. memset(&key, 0, sizeof(key));
  334. memset(&data, 0, sizeof(data));
  336. while (cursor->c_get(cursor, &key, &data, DB_NEXT) == 0) {
  337. uint32 uin = *(uint32 *) key.data;
  338. if (uin > 0 && uin <= 0xfffffff0) {
  339. DBInStream in(data.data, data.size);
  340. IcqContact *c = new IcqContact;
  341. c->load(in);
  342. contactList.push_back(c);
  343. }
  344. }
  346. cursor->c_close(cursor);
  347. db->close(db, 0);
  348. return true;
  349. }
  351. bool IcqDB::delContact(uint32 uin)
  352. {
  353. return delIndex(userFile, uin);
  354. }
  356. bool IcqDB::saveUser(IcqUser &user)
  357. {
  358. return saveBlock(userFile, INDEX_USER, user, false);
  359. }
  361. bool IcqDB::loadUser(IcqUser &user)
  362. {
  363. return loadBlock(userFile, INDEX_USER, user);
  364. }
  366. bool IcqDB::saveOptions(IcqOption &options)
  367. {
  368. return saveBlock(userFile, INDEX_OPTIONS, options, false);
  369. }
  371. bool IcqDB::loadOptions(IcqOption &options)
  372. {
  373. return loadBlock(userFile, INDEX_OPTIONS, options);
  374. }
  376. bool IcqDB::saveGroupInfo(DBSerialize &obj)
  377. {
  378. return saveBlock(userFile, INDEX_GROUP, obj, false);
  379. }
  381. bool IcqDB::loadGroupInfo(DBSerialize &obj)
  382. {
  383. return loadBlock(userFile, INDEX_GROUP, obj);
  384. }
  386. bool IcqDB::exportMsg(const char *pathName, uint32 uin)
  387. {
  388. PtrList msgList;
  389. if (!loadMsg(uin, msgList))
  390. return false;
  392. DB *db = getDBFullPath(pathName, true);
  393. if (!db)
  394. return false;
  396. bool cont = true;
  397. while (!msgList.empty() && cont) {
  398. IcqMsg *msg = (IcqMsg *) msgList.front();
  399. msgList.pop_front();
  401. cont = saveBlock(db, uin, *msg);
  402. delete msg;
  403. }
  405. db->close(db, 0);
  406. return cont;
  407. }
  409. bool IcqDB::importRecord(const char *pathName)
  410. {
  411. bool ret = false;
  412. DB *db = getDBFullPath(pathName, true);
  413. DB *dbOut = getDB(msgFile, true);
  414. if (!db || !dbOut)
  415. goto import_exit;
  417. DBC *cursor;
  418. if (db->cursor(db, NULL, &cursor, 0) != 0)
  419. goto import_exit;
  421. DBT key, data;
  422. memset(&key, 0, sizeof(key));
  423. memset(&data, 0, sizeof(data));
  425. ret = true;
  426. while (cursor->c_get(cursor, &key, &data, DB_NEXT) == 0 && ret)
  427. ret = (dbOut->put(dbOut, NULL, &key, &data, 0) == 0);
  429. import_exit:
  430. if (db)
  431. db->close(db, 0);
  432. if (dbOut)
  433. dbOut->close(dbOut, 0);
  434. return ret;
  435. }
  437. bool IcqDB::saveConfig(const char *fileName, DBSerialize &obj)
  438. {
  439. string pathName = dbDir + fileName;
  440. FILE *file = fopen(pathName.c_str(), "wb");
  441. if (!file)
  442. return false;
  444. DBOutStream out;
  445. obj.save(out);
  446. fwrite(out.getData(), out.getSize(), 1, file);
  448. fclose(file);
  449. return true;
  450. }
  452. bool IcqDB::loadConfig(const char *fileName, DBSerialize &obj)
  453. {
  454. string pathName = dbDir + fileName;
  455. FILE *file = fopen(pathName.c_str(), "rb");
  456. if (!file)
  457. return false;
  459. char buf[4096];
  460. int n = fread(buf, 1, sizeof(buf), file);
  461. fclose(file);
  463. DBInStream in(buf, n);
  464. obj.load(in);
  465. return true;
  466. }
  468. bool IcqDB::getMsgUinList(UinList &uinList)
  469. {
  470. DB *db = getDB(msgFile, true);
  471. if (!db)
  472. return false;
  474. DBC *cursor;
  475. if (db->cursor(db, NULL, &cursor, 0) != 0) {
  476. db->close(db, 0);
  477. return false;
  478. }
  480. DBT key, data;
  481. memset(&key, 0, sizeof(key));
  482. memset(&data, 0, sizeof(data));
  484. while (cursor->c_get(cursor, &key, &data, DB_NEXT_NODUP) == 0)
  485. uinList.push_back(*(uint32 *) key.data);
  487. return true;
  488. }
  490. void IcqDB::loadStrList(const char *fileName, StrList &l)
  491. {
  492. string pathName = dbDir + fileName;
  493. FILE *file = fopen(pathName.c_str(), "r");
  495. if (file) {
  496. char line[128];
  497. while (fgets(line, sizeof(line), file)) {
  498. int len = strlen(line);
  499. if (len > 0) {
  500. if (line[len - 1] == 'n')
  501. line[len - 1] = '';
  502. l.push_back(line);
  503. }
  504. }
  505. fclose(file);
  506. }
  507. }
  509. void IcqDB::saveStrList(const char *fileName, StrList &l)
  510. {
  511. string pathName = dbDir + fileName;
  512. FILE *file = fopen(pathName.c_str(), "w");
  514. if (file) {
  515. StrList::iterator it;
  516. for (it = l.begin(); it != l.end(); ++it)
  517. fprintf(file, "%sn", (*it).c_str());
  518. fclose(file);
  519. }
  520. }
  522. void IcqDB::loadQuickReply(StrList &l) {
  523. loadStrList(quickReplyFile, l);
  524. }
  526. void IcqDB::saveQuickReply(StrList &l) {
  527. saveStrList(quickReplyFile, l);
  528. }
  530. void IcqDB::loadAutoReply(StrList &l) {
  531. loadStrList(autoReplyFile, l);
  532. }
  534. void IcqDB::saveAutoReply(StrList &l) {
  535. saveStrList(autoReplyFile, l);
  536. }