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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
storage_cdb.c
资源名称：pvpgn-1.6.2.rar　[点击查看]
上传用户：tany51
上传日期：2013-06-12
资源大小：1397k
文件大小：23k
源码类别：

MySQL数据库

开发平台：

Visual C++

storage_cdb.c：源码内容
  1. /*
  2.  * Copyright (C) 2003 Mihai RUSU (dizzy@rdsnet.ro)
  3.  *
  4.  * This program is free software; you can redistribute it and/or
  5.  * modify it under the terms of the GNU General Public License
  6.  * as published by the Free Software Foundation; either version 2
  7.  * of the License, or (at your option) any later version.
  8.  *
  9.  * This program is distributed in the hope that it will be useful,
  10.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12.  * GNU General Public License for more details.
  13.  *
  14.  * You should have received a copy of the GNU General Public License
  15.  * along with this program; if not, write to the Free Software
  16.  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  17.  */
  18. #include "common/setup_before.h"
  19. #include <stdio.h>
  20. #ifdef HAVE_STDDEF_H
  21. # include <stddef.h>
  22. #else
  23. # ifndef NULL
  24. #  define NULL ((void *)0)
  25. # endif
  26. #endif
  27. #ifdef STDC_HEADERS
  28. # include <stdlib.h>
  29. #else
  30. # ifdef HAVE_MALLOC_H
  31. #  include <malloc.h>
  32. # endif
  33. #endif
  34. #ifdef HAVE_STRING_H
  35. # include <string.h>
  36. #else
  37. # ifdef HAVE_STRINGS_H
  38. #  include <strings.h>
  39. # endif
  40. #endif
  41. #include "compat/strchr.h"
  42. #include "compat/strdup.h"
  43. #include "compat/strcasecmp.h"
  44. #include "compat/strncasecmp.h"
  45. #include <ctype.h>
  46. #ifdef HAVE_LIMITS_H
  47. # include <limits.h>
  48. #endif
  49. #include "compat/char_bit.h"
  50. #ifdef TIME_WITH_SYS_TIME
  51. # include <sys/time.h>
  52. # include <time.h>
  53. #else
  54. # ifdef HAVE_SYS_TIME_H
  55. #  include <sys/time.h>
  56. # else
  57. #  include <time.h>
  58. # endif
  59. #endif
  60. #include <errno.h>
  61. #include "compat/strerror.h"
  62. #ifdef HAVE_SYS_TYPES_H
  63. # include <sys/types.h>
  64. #endif
  65. #ifdef HAVE_UNISTD_H
  66. # include <unistd.h>
  67. #else
  68. # ifdef WIN32
  69. #  include <io.h>
  70. # endif
  71. #endif
  72. #include "compat/pdir.h"
  73. #include "common/eventlog.h"
  74. #include "prefs.h"
  75. #include "common/util.h"
  76. #include "common/field_sizes.h"
  77. #include "common/bnethash.h"
  78. #include "common/introtate.h"
  79. #define CLAN_INTERNAL_ACCESS
  80. #define ACCOUNT_INTERNAL_ACCESS
  81. #include "account.h"
  82. #include "common/hashtable.h"
  83. #include "storage.h"
  84. #include "common/list.h"
  85. #include "connection.h"
  86. #include "watch.h"
  87. #include "clan.h"
  88. #undef ACCOUNT_INTERNAL_ACCESS
  89. #undef CLAN_INTERNAL_ACCESS
  90. #include "common/tag.h"
  91. #ifdef HAVE_FCNTL_H
  92. # include <fcntl.h>
  93. #else
  94. # ifdef HAVE_SYS_FILE_H
  95. #  include <sys/file.h>
  96. # endif
  97. #endif
  98. #include "tinycdb/cdb.h"
  99. #include "common/setup_after.h"
  101. /* cdb storage API functions */
  103. static int cdbs_init(const char *);
  104. static int cdbs_close(void);
  105. static t_storage_info * cdb_create_account(char const *);
  106. static t_storage_info * cdb_get_defacct(void);
  107. static int cdb_free_info(t_storage_info *);
  108. static int cdb_read_attrs(t_storage_info *, t_read_attr_func, void *);
  109. static void * cdb_read_attr(t_storage_info *, const char *);
  110. static int cdb_write_attrs(t_storage_info *, void *);
  111. static int cdb_read_accounts(t_read_accounts_func, void *);
  112. static void * cdb_read_account(t_read_account_func, const char *);
  113. static int cdb_cmp_info(t_storage_info *, t_storage_info *);
  114. static const char * cdb_escape_key(const char *);
  115. static int cdb_load_clans(t_load_clans_func);
  116. static int cdb_write_clan(void *);
  117. static int cdb_remove_clan(int);
  118. static int cdb_remove_clanmember(int);
  120. /* storage struct populated with the functions above */
  122. t_storage storage_cdb = {
  123.     cdbs_init,
  124.     cdbs_close,
  125.     cdb_create_account,
  126.     cdb_get_defacct,
  127.     cdb_free_info,
  128.     cdb_read_attrs,
  129.     cdb_write_attrs,
  130.     cdb_read_attr,
  131.     cdb_read_accounts,
  132.     cdb_read_account,
  133.     cdb_cmp_info,
  134.     cdb_escape_key,
  135.     cdb_load_clans,
  136.     cdb_write_clan,
  137.     cdb_remove_clan,
  138.     cdb_remove_clanmember
  139. };
  141. /* start of actual cdb file storage code */
  143. static const char *cdbdir = NULL;
  144. static const char *clansdir = NULL;
  145. static const char *defacct = NULL;
  147. //#define CDB_ON_DEMAND 1
  149. static int cdbs_init(const char *path)
  150. {
  151.     char *tok, *copy, *tmp, *p;
  152.     const char *dir = NULL;
  153.     const char *clan = NULL;
  154.     const char *def = NULL;
  156.     if (path == NULL || path[0] == '') {
  157.         eventlog(eventlog_level_error, __FUNCTION__, "got NULL or empty path");
  158.         return -1;
  159.     }
  161.     if ((copy = strdup(path)) == NULL) {
  162.         eventlog(eventlog_level_error, __FUNCTION__, "could not duplicate path");
  163.         return -1;
  164.     }
  166.     tmp = copy;
  167.     while((tok = strtok(tmp, ";")) != NULL) {
  168.         tmp = NULL;
  169.         if ((p = strchr(tok, '=')) == NULL) {
  170.             eventlog(eventlog_level_error, __FUNCTION__, "invalid storage_path, no '=' present in token");
  171.             free((void*)copy);
  172.             return -1;
  173.         }
  174.         *p = '';
  175.         if (strcasecmp(tok, "dir") == 0)
  176.             dir = p + 1;
  177.         else if (strcasecmp(tok, "clan") == 0)
  178.         clan = p + 1;
  179.         else if (strcasecmp(tok, "default") == 0)
  180.             def = p + 1;
  181.         else eventlog(eventlog_level_warn, __FUNCTION__, "unknown token in storage_path : '%s'", tok);
  182.     }
  184.     if (def == NULL || clan ==NULL || dir == NULL) {
  185.         eventlog(eventlog_level_error, __FUNCTION__, "invalid storage_path line for cdb file module (doesnt have a 'dir', a 'clan' and a 'default' token)");
  186.         free((void*)copy);
  187.         return -1;
  188.     }
  190.     if (cdbdir) cdbs_close();
  192.     if ((cdbdir = strdup(dir)) == NULL) {
  193.         eventlog(eventlog_level_error, __FUNCTION__, "not enough memory to store cdb accounts dir");
  194.         free((void*)copy);
  195.         return -1;
  196.     }
  198.     if ((clansdir = strdup(clan)) == NULL) {
  199. eventlog(eventlog_level_error, __FUNCTION__, "not enough memory to store clans dir");
  200. free((void*)copy);
  201. return -1;
  202.     }
  204.     if ((defacct = strdup(def)) == NULL) {
  205.         eventlog(eventlog_level_error, __FUNCTION__, "not enough memory to store default cdb account path");
  206.         free((void*)cdbdir); cdbdir = NULL;
  207.         free((void*)copy);
  208.         return -1;
  209.     }
  211.     free((void*)copy);
  212.     return 0;
  213. }
  215. static int cdbs_close(void)
  216. {
  217.     if (cdbdir) free((void*)cdbdir);
  218.     cdbdir = NULL;
  220.     if (clansdir) free((void*)clansdir);
  221.     clansdir = NULL;
  223.     if (defacct) free((void*)defacct);
  224.     defacct = NULL;
  226.     return 0;
  227. }
  229. static t_storage_info * cdb_create_account(const char * username)
  230. {
  231.     char *temp;
  233.     if (cdbdir == NULL) {
  234. eventlog(eventlog_level_error, __FUNCTION__, "file storage not initilized");
  235. return NULL;
  236.     }
  238.     if (prefs_get_savebyname())
  239.     {
  240. char const * safename;
  242. if (!(safename = escape_fs_chars(username,strlen(username))))
  243. {
  244.     eventlog(eventlog_level_error, __FUNCTION__, "could not escape username");
  245.     return NULL;
  246. }
  247. if (!(temp = malloc(strlen(cdbdir)+1+strlen(safename)+1))) /* dir + / + name + NUL */
  248. {
  249.     eventlog(eventlog_level_error, __FUNCTION__, "could not allocate memory for temp");
  250.     free((void *)safename);
  251.     return NULL;
  252. }
  253. sprintf(temp,"%s/%s",cdbdir,safename);
  254. free((void *)safename); /* avoid warning */
  255.     } else {
  256. if (!(temp = malloc(strlen(cdbdir)+1+8+1))) /* dir + / + uid + NUL */
  257. {
  258.     eventlog(eventlog_level_error, __FUNCTION__, "could not allocate memory for temp");
  259.     return NULL;
  260. }
  261. sprintf(temp,"%s/%06u",cdbdir,maxuserid+1); /* FIXME: hmm, maybe up the %06 to %08... */
  262.     }
  264.     return temp;
  265. }
  267. static int cdb_write_attrs(t_storage_info *info, void *attributes)
  268. {
  269.     FILE           *cdbfile;
  270.     t_attribute * attr;
  271.     char *        tempname;
  272.     struct cdb_make cdbm;
  274.     if (cdbdir == NULL) {
  275. eventlog(eventlog_level_error, __FUNCTION__, "cdb storage not initilized");
  276. return -1;
  277.     }
  279.     if (info == NULL) {
  280. eventlog(eventlog_level_error, __FUNCTION__, "got NULL info storage");
  281. return -1;
  282.     }
  284.     if (attributes == NULL) {
  285. eventlog(eventlog_level_error, __FUNCTION__, "got NULL attributes");
  286. return -1;
  287.     }
  289.     if (!(tempname = malloc(strlen(cdbdir)+1+strlen(BNETD_ACCOUNT_TMP)+1))) {
  290. eventlog(eventlog_level_error, __FUNCTION__, "unable to allocate memory for tempname");
  291.         return -1;
  292.     }
  294.     sprintf(tempname,"%s/%s", cdbdir, BNETD_ACCOUNT_TMP);
  296.     if ((cdbfile = fopen(tempname, "w+b")) == NULL) {
  297. eventlog(eventlog_level_error, __FUNCTION__, "unable to open file "%s" for writing ",tempname);
  298. free(tempname);
  299. return -1;
  300.     }
  302.     cdb_make_start(&cdbm, cdbfile);
  303.     for (attr=(t_attribute *)attributes; attr; attr=attr->next) {
  304. if (attr->key && attr->val) {
  305.     if (strncmp("BNET\CharacterDefault\", attr->key, 20) == 0) {
  306. eventlog(eventlog_level_debug, __FUNCTION__, "skipping attribute key="%s"",attr->key);
  307.     } else {
  308. eventlog(eventlog_level_debug, __FUNCTION__, "saving attribute key="%s" val="%s"",attr->key,attr->val);
  309. cdb_make_add(&cdbm, attr->key, strlen(attr->key), attr->val, strlen(attr->val));
  310.     }
  311. } else eventlog(eventlog_level_error, __FUNCTION__,"could not save attribute key="%s"",attr->key);
  313.     }
  315.     cdb_make_finish(&cdbm);
  316.     fclose(cdbfile);
  317.    
  318. #ifdef WIN32
  319.    /* We are about to rename the temporary file
  320.     * to replace the existing account.  In Windows,
  321.     * we have to remove the previous file or the
  322.     * rename function will fail saying the file
  323.     * already exists.  This defeats the purpose of
  324.     * the rename which was to make this an atomic
  325.     * operation.  At least the race window is small.
  326.     */
  327.     if (access((const char *)info, 0) == 0) {
  328. if (remove((const char *)info)<0) {
  329.     eventlog(eventlog_level_error, __FUNCTION__, "could not delete account file "%s" (remove: %s)", (char *)info, strerror(errno));
  330.             free(tempname);
  331.     return -1;
  332. }
  333.     }
  334. #endif
  335.    
  336.     if (rename(tempname,(const char *)info)<0) {
  337. eventlog(eventlog_level_error, __FUNCTION__, "could not rename account file to "%s" (rename: %s)", (char *)info, strerror(errno));
  338. free(tempname);
  339. return -1;
  340.     }
  342.     free(tempname);
  344.     return 0;
  345. }
  347. #ifndef CDB_ON_DEMAND
  348. /* code adapted from tinycdb-0.73/cdb.c */
  350. static int fget(FILE * fd, unsigned char *b, cdbi_t len, cdbi_t *posp, cdbi_t limit)
  351. {
  352.     if (posp && limit - *posp < len) {
  353. eventlog(eventlog_level_error, __FUNCTION__, "invalid cdb database format");
  354. return -1;
  355.     }
  357.     if (fread(b, 1, len, fd) != len) {
  358. if (ferror(fd)) {
  359.     eventlog(eventlog_level_error, __FUNCTION__, "got error reading from db file");
  360.     return -1;
  361. }
  362. eventlog(eventlog_level_error, __FUNCTION__, "unable to read from cdb file, incomplete file");
  363. return -1;
  364.     }
  366.     if (posp) *posp += len;
  367.     return 0;
  368. }
  370. static const char * fcpy(FILE *fd, cdbi_t len, cdbi_t *posp, cdbi_t limit, unsigned char * buf)
  371. {
  372.     static char *str;
  373.     static unsigned strl;
  374.     unsigned int res = 0, no = 0;
  376.     if (strl < len + 1) {
  377. char *tmp;
  378. if ((tmp = malloc(len + 1)) == NULL) {
  379.     eventlog(eventlog_level_error, __FUNCTION__, "could not alloc memory to read from db");
  380.     return NULL;
  381. }
  383. if (str) free((void*)str);
  384. str = tmp;
  385. strl = len + 1;
  386.     }
  388.     while(len - res > 0) {
  389. if (len > 2048) no = 2048;
  390. else no = len;
  392. fget(fd, buf, no, posp, limit);
  393. memmove(str + res, buf, no);
  394. res += no;
  395.     }
  397.     if (res > strl - 1) {
  398. eventlog(eventlog_level_error, __FUNCTION__, "BUG, this should nto happen");
  399. return NULL;
  400.     }
  402.     str[res] = '';
  403.     return str;
  404. }
  406. static int cdb_read_attrs(t_storage_info *info, t_read_attr_func cb, void *data)
  407. {
  408.     cdbi_t eod, klen, vlen;
  409.     cdbi_t pos = 0;
  410.     const char *key;
  411.     const char *val;
  412.     unsigned char buf[2048];
  413.     FILE *f;
  415.     if (cdbdir == NULL) {
  416. eventlog(eventlog_level_error, __FUNCTION__, "cdb storage not initilized");
  417. return -1;
  418.     }
  420.     if (info == NULL) {
  421. eventlog(eventlog_level_error, __FUNCTION__, "got NULL info storage");
  422. return -1;
  423.     }
  425.     if (cb == NULL) {
  426. eventlog(eventlog_level_error, __FUNCTION__, "got NULL callback");
  427. return -1;
  428.     }
  430.     if ((f = fopen(info, "rb")) == NULL) {
  431. eventlog(eventlog_level_error, __FUNCTION__, "got error opening file '%s'", (char *)info);
  432. return -1;
  433.     }
  435.     fget(f, buf, 2048, &pos, 2048);
  436.     eod = cdb_unpack(buf);
  437.     while(pos < eod) {
  438. fget(f, buf, 8, &pos, eod);
  439. klen = cdb_unpack(buf);
  440. vlen = cdb_unpack(buf + 4);
  441. if ((key = fcpy(f, klen, &pos, eod, buf)) == NULL) {
  442.     eventlog(eventlog_level_error, __FUNCTION__, "error reading attribute key");
  443.     fclose(f);
  444.     return -1;
  445. }
  447. if ((key = strdup(key)) == NULL) {
  448.     eventlog(eventlog_level_error, __FUNCTION__, "error duplicating attribute key");
  449.     fclose(f);
  450.     return -1;
  451. }
  453. if ((val = fcpy(f, vlen, &pos, eod, buf)) == NULL) {
  454.     eventlog(eventlog_level_error, __FUNCTION__, "error reading attribute val");
  455.     free((void *)key);
  456.     fclose(f);
  457.     return -1;
  458. }
  460. // eventlog(eventlog_level_trace, __FUNCTION__, "read atribute : '%s' -> '%s'", key, val);
  461. cb(key, val, data);
  462. free((void *)key);
  463.     }
  465.     fclose(f);
  466.     return 0;
  467. }
  468. #else /* CDB_ON_DEMAND */
  469. static int cdb_read_attrs(t_storage_info *info, t_read_attr_func cb, void *data)
  470. {
  471.     return 0;
  472. }
  473. #endif
  475. static void * cdb_read_attr(t_storage_info *info, const char *key)
  476. {
  477. #ifdef CDB_ON_DEMAND
  478.     FILE *cdbfile;
  479.     t_attribute *attr;
  480.     const char *filename = (const char *)info;
  481.     char *val;
  482.     unsigned vlen = 1;
  484.     if (!cdbdir) {
  485. eventlog(eventlog_level_error, __FUNCTION__, "cdb storage not initilized");
  486. return NULL;
  487.     }
  489.     if (key == NULL) {
  490. eventlog(eventlog_level_error, __FUNCTION__, "got NULL key");
  491. return NULL;
  492.     }
  494. //    eventlog(eventlog_level_trace, __FUNCTION__, "reading key '%s'", key);
  495.     if ((cdbfile = fopen(filename, "rb")) == NULL) {
  496. // eventlog(eventlog_level_debug, __FUNCTION__, "unable to open file "%s" for reading ",filename);
  497. return NULL;
  498.     }
  500.     if (cdb_seek(cdbfile, key, strlen(key), &vlen) <= 0) {
  501. // eventlog(eventlog_level_debug, __FUNCTION__, "could not find key '%s'", key);
  502. fclose(cdbfile);
  503. return NULL;
  504.     }
  506.     if ((attr = malloc(sizeof(t_attribute))) == NULL) {
  507. eventlog(eventlog_level_error, __FUNCTION__, "not enough memory for attr result");
  508. fclose(cdbfile);
  509. return NULL;
  510.     }
  512.     if ((attr->key = strdup(key)) == NULL) {
  513. eventlog(eventlog_level_error, __FUNCTION__, "not enough memory for attr key result");
  514. free((void*)attr);
  515. fclose(cdbfile);
  516. return NULL;
  517.     }
  519.     if ((val = malloc(vlen + 1)) == NULL) {
  520. eventlog(eventlog_level_error, __FUNCTION__, "not enough memory for attr val result");
  521. free((void*)attr->key);
  522. free((void*)attr);
  523. fclose(cdbfile);
  524. return NULL;
  525.     }
  527.     cdb_bread(cdbfile, val, vlen);
  528. fclose(cdbfile);
  530.     val[vlen] = '';
  532.     attr->val = val;
  533.     attr->dirty = 0;
  534. //    eventlog(eventlog_level_trace, __FUNCTION__, "read key '%s' value '%s'", attr->key, attr->val);
  535.     return attr;
  536. #else
  537.     return NULL;
  538. #endif
  539. }
  541. static int cdb_free_info(t_storage_info *info)
  542. {
  543.     if (info) free((void*)info);
  544.     return 0;
  545. }
  547. static t_storage_info * cdb_get_defacct(void)
  548. {
  549.     t_storage_info * info;
  551.     if (defacct == NULL) {
  552.         eventlog(eventlog_level_error, __FUNCTION__, "cdb storage not initilized");
  553. return NULL;
  554.     }
  556.     if ((info = strdup(defacct)) == NULL) {
  557.         eventlog(eventlog_level_error, __FUNCTION__, "could not duplicate default account cdb filename");
  558. return NULL;
  559.     }
  561.     return info;
  562. }
  564. static int cdb_read_accounts(t_read_accounts_func cb, void *data)
  565. {
  566.     char const * dentry;
  567.     char *       pathname;
  568.     t_pdir *     accountdir;
  570.     if (cdbdir == NULL) {
  571. eventlog(eventlog_level_error, __FUNCTION__, "file storage not initilized");
  572. return -1;
  573.     }
  575.     if (cb == NULL) {
  576. eventlog(eventlog_level_error, __FUNCTION__, "got NULL callback");
  577. return -1;
  578.     }
  580.     if (!(accountdir = p_opendir(cdbdir))) {
  581. eventlog(eventlog_level_error, __FUNCTION__, "unable to open user directory "%s" for reading (p_opendir: %s)",cdbdir,strerror(errno));
  582. return -1;
  583.     }
  585.     while ((dentry = p_readdir(accountdir))) {
  586. if (dentry[0]=='.') continue;
  588. if (!(pathname = malloc(strlen(cdbdir)+1+strlen(dentry)+1))) /* dir + / + file + NUL */
  589.  {
  590.    eventlog(eventlog_level_error, __FUNCTION__, "could not allocate memory for pathname");
  591.    continue;
  592.  }
  593. sprintf(pathname,"%s/%s", cdbdir, dentry);
  595. cb(pathname, data);
  596.     }
  598.     if (p_closedir(accountdir)<0)
  599. eventlog(eventlog_level_error, __FUNCTION__,"unable to close user directory "%s" (p_closedir: %s)", cdbdir,strerror(errno));
  601.     return 0;
  602. }
  604. static void * cdb_read_account(t_read_account_func cb, const char * name)
  605. {
  606.     char *       pathname;
  608.     if (cdbdir == NULL) {
  609. eventlog(eventlog_level_error, __FUNCTION__, "file storage not initilized");
  610. return NULL;
  611.     }
  613.     if (cb == NULL) {
  614. eventlog(eventlog_level_error, __FUNCTION__, "got NULL callback");
  615. return NULL;
  616.     }
  618.     if (!(pathname = malloc(strlen(cdbdir)+1+strlen(name)+1))) /* dir + / + file + NUL */
  619.     {
  620. eventlog(eventlog_level_error, __FUNCTION__, "could not allocate memory for pathname");
  621. return NULL;
  622.     }
  623.     sprintf(pathname,"%s/%s", cdbdir, name);
  624.     if (access(pathname,0)) /* if it doesn't exist */
  625.     {
  626. free((void *) pathname);
  627. return NULL;
  628.     }
  630.     return cb(pathname);
  631. }
  634. static int cdb_cmp_info(t_storage_info *info1, t_storage_info *info2)
  635. {
  636.     return strcmp((const char *)info1, (const char *)info2);
  637. }
  639. static const char * cdb_escape_key(const char * key)
  640. {
  641.     return key;
  642. }
  644. static int cdb_load_clans(t_load_clans_func cb)
  645. {
  646.   char const *dentry;
  647.   t_pdir *clandir;
  648.   char *pathname;
  649.   int       clantag;
  650.   t_clan *clan;
  651.   FILE *fp;
  652.   char clanname[CLAN_NAME_MAX+1];
  653.   char motd[51];
  654.   int cid, creation_time;
  655.   int member_uid, member_join_time;
  656.   char member_status;
  657.   t_clanmember *member;
  658.   
  659.     if (cb == NULL) {
  660. eventlog(eventlog_level_error, __FUNCTION__, "get NULL callback");
  661. return -1;
  662.     }
  664.   if (!(clandir = p_opendir(clansdir)))
  665.     {
  666.       eventlog(eventlog_level_error,__FUNCTION__,"unable to open clan directory "%s" for reading (p_opendir: %s)",clansdir,strerror(errno));
  667.       return -1;
  668.     }
  669.   eventlog(eventlog_level_trace,__FUNCTION__,"start reading clans");
  671.   if (!(pathname = malloc(strlen(clansdir)+1+4+1)))
  672. {
  673.   eventlog(eventlog_level_error,__FUNCTION__,"could not allocate memory for pathname");
  674.   return -1;
  675. }
  677.     while ((dentry = p_readdir(clandir)) != NULL)
  678.     {
  679.       if (dentry[0]=='.') continue;
  680.     
  681.       sprintf(pathname,"%s/%s",clansdir,dentry);
  683.       if (strlen(dentry)>4)
  684. {
  685.   eventlog(eventlog_level_error,__FUNCTION__,"found too long clan filename in clandir "%s"",dentry);
  686.   continue;
  687. }
  688.     
  689.       clantag = str_to_clantag(dentry);
  691.   if ((fp = fopen(pathname,"r"))==NULL)
  692.     {
  693.       eventlog(eventlog_level_error,__FUNCTION__,"can't open clanfile "%s"",pathname);
  694.       continue;
  695.     }
  697.   if(!(clan = malloc(sizeof(t_clan))))
  698.   {
  699.     eventlog(eventlog_level_error,__FUNCTION__,"could not allocate memory for clan");
  700.     free((void *)pathname);
  701.     p_closedir(clandir);
  702.     return -1;
  703.   }
  705.   clan->clantag=clantag;
  707.   fscanf(fp,""%[^"]","%[^"]",%i,%in",clanname,motd,&cid,&creation_time);
  708.   clan->clanname = strdup(clanname);
  709.   clan->clan_motd = strdup(motd);
  710.   clan->clanid = cid;
  711.   clan->creation_time=(time_t)creation_time;
  712.   clan->created = 1;
  713.   clan->modified = 0;
  714.   clan->channel_type = prefs_get_clan_channel_default_private();
  715.  
  716.   eventlog(eventlog_level_trace,__FUNCTION__,"name: %s motd: %s clanid: %i time: %i",clanname,motd,cid,creation_time);
  718.   clan->members = list_create();
  720.   while (fscanf(fp,"%i,%c,%in",&member_uid,&member_status,&member_join_time)==3)
  721.     {
  722.       if (!(member = malloc(sizeof(t_clanmember))))
  723. {
  724.   eventlog(eventlog_level_error,__FUNCTION__,"cannot allocate memory for clan member");
  725.   clan_remove_all_members(clan);
  726.       if(clan->clanname)
  727.     free((void *)clan->clanname);
  728.       if(clan->clan_motd)
  729.         free((void *)clan->clan_motd);
  730.   free((void *)clan);
  731.       fclose(fp);
  732.       free((void *)pathname);
  733.       p_closedir(clandir);
  734.   return -1;
  735. }
  736.       if(!(member->memberacc   = accountlist_find_account_by_uid(member_uid)))
  737.       {
  738.     eventlog(eventlog_level_error,__FUNCTION__,"cannot find uid %u", member_uid);
  739.     free((void *)member);
  740.     continue;
  741.       }
  742.       member->memberconn  = NULL;
  743.       member->status    = member_status-'0';
  744.       member->join_time = member_join_time;
  745.       member->clan = clan;
  747.       if((member->status==CLAN_NEW)&&(time(NULL)-member->join_time>prefs_get_clan_newer_time()*3600))
  748.       {
  749.           member->status = CLAN_PEON;
  750.           clan->modified = 1;
  751.       }
  753.       if (list_append_data(clan->members,member)<0)
  754. {
  755.   eventlog(eventlog_level_error,__FUNCTION__,"could not append item");
  756.   free((void *)member);
  757.   clan_remove_all_members(clan);
  758.       if(clan->clanname)
  759.     free((void *)clan->clanname);
  760.       if(clan->clan_motd)
  761.     free((void *)clan->clan_motd);
  762.   free((void *)clan);
  763.       fclose(fp);
  764.       free((void *)pathname);
  765.       p_closedir(clandir);
  766.   return -1;
  767. }
  768.       account_set_clanmember(member->memberacc, member);
  769.       eventlog(eventlog_level_trace,__FUNCTION__,"added member: uid: %i status: %c join_time: %i",member_uid,member_status+'0',member_join_time);
  770.     }
  772.   fclose(fp);
  774.       cb(clan);
  776.     }
  778.       free((void *)pathname);
  780.   if (p_closedir(clandir)<0)
  781.     {
  782.       eventlog(eventlog_level_error,__FUNCTION__,"unable to close clan directory "%s" (p_closedir: %s)",clansdir,strerror(errno));
  783.     }
  784.   eventlog(eventlog_level_trace,__FUNCTION__,"finished reading clans");
  786.   return 0;
  787. }
  789. static int cdb_write_clan(void * data)
  790. {
  791.   FILE *fp;
  792.   t_elem *curr;
  793.   t_clanmember *member;
  794.   char *clanfile;
  795.   t_clan        *clan=(t_clan *)data;
  796.   if (!(clanfile = malloc(strlen(clansdir)+1+4+1)))
  797.     {
  798.       eventlog(eventlog_level_error,__FUNCTION__,"could not allocate memory for filename");
  799.       return -1;
  800.     }
  802.   sprintf(clanfile,"%s/%c%c%c%c",clansdir,
  803.   clan->clantag>>24,(clan->clantag>>16)&0xff,
  804.   (clan->clantag>>8)&0xff,clan->clantag&0xff);
  806.   if ((fp = fopen(clanfile,"w"))==NULL)
  807.     {
  808.       eventlog(eventlog_level_error,__FUNCTION__,"can't open clanfile "%s"",clanfile);
  809.       free((void *)clanfile);
  810.       return -1;
  811.     }
  813.   fprintf(fp,""%s","%s",%i,%in",clan->clanname,clan->clan_motd,clan->clanid,(int)clan->creation_time);
  815.   LIST_TRAVERSE(clan->members,curr)
  816.     {
  817.       if (!(member = elem_get_data(curr)))
  818. {
  819.   eventlog(eventlog_level_error,__FUNCTION__,"got NULL elem in list");
  820.   continue;
  821. }
  822.     if((member->status==CLAN_NEW)&&(time(NULL)-member->join_time>prefs_get_clan_newer_time()*3600))
  823.       member->status = CLAN_PEON;
  824.     fprintf(fp,"%i,%c,%un",account_get_uid(member->memberacc),member->status+'0',(unsigned)member->join_time);
  825.     }
  827.   fclose(fp);
  828.   free((void *)clanfile);
  829.   return 0;
  830. }
  832. static int cdb_remove_clan(int clantag)
  833. {
  834.     char * tempname;
  835.     if (!(tempname = malloc(strlen(clansdir)+1+4+1)))
  836. {
  837.   eventlog(eventlog_level_error,__FUNCTION__,"could not allocate memory for pathname");
  838.   return -1;
  839. }
  840.     sprintf(tempname, "%s/%c%c%c%c", clansdir, clantag>>24, (clantag>>16)&0xff, (clantag>>8)&0xff, clantag&0xff);
  841. if (remove((const char *)tempname)<0) {
  842.     eventlog(eventlog_level_error, __FUNCTION__, "could not delete clan file "%s" (remove: %s)", (char *)tempname, strerror(errno));
  843.         free(tempname);
  844.     return -1;
  845. }
  846.     free(tempname);
  847.     return 0;
  848. }
  850. static int cdb_remove_clanmember(int uid)
  851. {
  852.     return 0;
  853. }