/[LeafOK_CVS]/lbbs/src/user_list.c
ViewVC logotype

Diff of /lbbs/src/user_list.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

Revision 1.8 by sysadm, Wed Oct 22 07:16:48 2025 UTC Revision 1.31 by sysadm, Sun Nov 9 06:44:02 2025 UTC
# Line 1  Line 1 
1  /***************************************************************************  /* SPDX-License-Identifier: GPL-3.0-or-later */
2                                                   user_list.c  -  description  /*
3                                                           -------------------   * user_list
4          Copyright            : (C) 2004-2025 by Leaflet   *   - data model and basic operations of (online) user list
5          Email                : leaflet@leafok.com   *
6   ***************************************************************************/   * Copyright (C) 2004-2025  Leaflet <leaflet@leafok.com>
7     */
 /***************************************************************************  
  *                                                                         *  
  *   This program is free software; you can redistribute it and/or modify  *  
  *   it under the terms of the GNU General Public License as published by  *  
  *   the Free Software Foundation; either version 3 of the License, or     *  
  *   (at your option) any later version.                                   *  
  *                                                                         *  
  ***************************************************************************/  
8    
9  #include "common.h"  #include "common.h"
10  #include "database.h"  #include "database.h"
11  #include "log.h"  #include "log.h"
12  #include "trie_dict.h"  #include "trie_dict.h"
13  #include "user_list.h"  #include "user_list.h"
14    #include "user_stat.h"
15  #include <errno.h>  #include <errno.h>
16  #include <stdlib.h>  #include <stdlib.h>
17  #include <string.h>  #include <string.h>
# Line 40  union semun Line 33  union semun
33  };  };
34  #endif // #ifdef _SEM_SEMUN_UNDEFINED  #endif // #ifdef _SEM_SEMUN_UNDEFINED
35    
36  #define USER_LIST_TRY_LOCK_WAIT_TIME 1 // second  enum _user_list_constant_t
37  #define USER_LIST_TRY_LOCK_TIMES 10  {
38            USER_LIST_TRY_LOCK_WAIT_TIME = 1, // second
39            USER_LIST_TRY_LOCK_TIMES = 10,
40    };
41    
42  struct user_list_pool_t  struct user_list_pool_t
43  {  {
# Line 53  struct user_list_pool_t Line 49  struct user_list_pool_t
49          USER_ONLINE_LIST user_online_list[2];          USER_ONLINE_LIST user_online_list[2];
50          USER_ONLINE_LIST *p_online_current;          USER_ONLINE_LIST *p_online_current;
51          USER_ONLINE_LIST *p_online_new;          USER_ONLINE_LIST *p_online_new;
52            USER_STAT_MAP user_stat_map;
53            int user_login_count;
54  };  };
55  typedef struct user_list_pool_t USER_LIST_POOL;  typedef struct user_list_pool_t USER_LIST_POOL;
56    
# Line 91  static int user_list_rd_lock(int semid); Line 89  static int user_list_rd_lock(int semid);
89  static int user_list_rw_lock(int semid);  static int user_list_rw_lock(int semid);
90    
91  static int user_list_load(MYSQL *db, USER_LIST *p_list);  static int user_list_load(MYSQL *db, USER_LIST *p_list);
92  static int user_online_list_load(MYSQL *db, USER_ONLINE_LIST *p_list);  static int user_online_list_load(MYSQL *db, USER_ONLINE_LIST *p_online_list);
93    static int user_login_count_load(MYSQL *db);
94    
95  static int user_info_index_uid_comp(const void *ptr1, const void *ptr2)  static int user_info_index_uid_comp(const void *ptr1, const void *ptr2)
96  {  {
# Line 106  static int user_info_index_uid_comp(cons Line 105  static int user_info_index_uid_comp(cons
105          {          {
106                  return 1;                  return 1;
107          }          }
108            else if (p1->id < p2->id)
109            {
110                    return -1;
111            }
112            else if (p1->id > p2->id)
113            {
114                    return 1;
115            }
116          return 0;          return 0;
117  }  }
118    
# Line 116  int user_list_load(MYSQL *db, USER_LIST Line 123  int user_list_load(MYSQL *db, USER_LIST
123          char sql[SQL_BUFFER_LEN];          char sql[SQL_BUFFER_LEN];
124          int ret = 0;          int ret = 0;
125          int i;          int i;
126            int j;
127            int32_t last_uid;
128            size_t intro_buf_offset;
129            size_t intro_len;
130    
131          if (db == NULL || p_list == NULL)          if (db == NULL || p_list == NULL)
132          {          {
# Line 123  int user_list_load(MYSQL *db, USER_LIST Line 134  int user_list_load(MYSQL *db, USER_LIST
134                  return -1;                  return -1;
135          }          }
136    
137            if (p_list->user_count > 0)
138            {
139                    last_uid = p_list->users[p_list->user_count - 1].uid;
140            }
141            else
142            {
143                    last_uid = -1;
144            }
145    
146          snprintf(sql, sizeof(sql),          snprintf(sql, sizeof(sql),
147                           "SELECT user_list.UID AS UID, username, nickname, gender, gender_pub, life, exp, "                           "SELECT user_list.UID AS UID, username, nickname, gender, gender_pub, life, exp, visit_count, "
148                           "UNIX_TIMESTAMP(signup_dt), UNIX_TIMESTAMP(last_login_dt), UNIX_TIMESTAMP(birthday) "                           "UNIX_TIMESTAMP(signup_dt), UNIX_TIMESTAMP(last_login_dt), UNIX_TIMESTAMP(last_logout_dt), "
149                             "UNIX_TIMESTAMP(birthday), `introduction` "
150                           "FROM user_list INNER JOIN user_pubinfo ON user_list.UID = user_pubinfo.UID "                           "FROM user_list INNER JOIN user_pubinfo ON user_list.UID = user_pubinfo.UID "
151                           "INNER JOIN user_reginfo ON user_list.UID = user_reginfo.UID "                           "INNER JOIN user_reginfo ON user_list.UID = user_reginfo.UID "
152                           "WHERE enable ORDER BY username");                           "WHERE enable ORDER BY username");
# Line 144  int user_list_load(MYSQL *db, USER_LIST Line 165  int user_list_load(MYSQL *db, USER_LIST
165                  goto cleanup;                  goto cleanup;
166          }          }
167    
168            intro_buf_offset = 0;
169          i = 0;          i = 0;
170          while ((row = mysql_fetch_row(rs)))          while ((row = mysql_fetch_row(rs)))
171          {          {
# Line 158  int user_list_load(MYSQL *db, USER_LIST Line 180  int user_list_load(MYSQL *db, USER_LIST
180                  p_list->users[i].gender_pub = (int8_t)(row[4] == NULL ? 0 : atoi(row[4]));                  p_list->users[i].gender_pub = (int8_t)(row[4] == NULL ? 0 : atoi(row[4]));
181                  p_list->users[i].life = (row[5] == NULL ? 0 : atoi(row[5]));                  p_list->users[i].life = (row[5] == NULL ? 0 : atoi(row[5]));
182                  p_list->users[i].exp = (row[6] == NULL ? 0 : atoi(row[6]));                  p_list->users[i].exp = (row[6] == NULL ? 0 : atoi(row[6]));
183                  p_list->users[i].signup_dt = (row[7] == NULL ? 0 : atol(row[7]));                  p_list->users[i].visit_count = (row[7] == NULL ? 0 : atoi(row[7]));
184                  p_list->users[i].last_login_dt = (row[8] == NULL ? 0 : atol(row[8]));                  p_list->users[i].signup_dt = (row[8] == NULL ? 0 : atol(row[8]));
185                  p_list->users[i].birthday = (row[9] == NULL ? 0 : atol(row[9]));                  p_list->users[i].last_login_dt = (row[9] == NULL ? 0 : atol(row[9]));
186                    p_list->users[i].last_logout_dt = (row[10] == NULL ? 0 : atol(row[10]));
187                  // index                  p_list->users[i].birthday = (row[11] == NULL ? 0 : atol(row[11]));
188                  p_list->index_uid[i].uid = p_list->users[i].uid;                  intro_len = strlen((row[12] == NULL ? "" : row[12]));
189                  p_list->index_uid[i].id = i;                  if (intro_len >= sizeof(p_list->user_intro_buf) - 1 - intro_buf_offset)
190                    {
191                            log_error("OOM for user introduction: len=%d, i=%d\n", intro_len, i);
192                            break;
193                    }
194                    memcpy(p_list->user_intro_buf + intro_buf_offset,
195                               (row[12] == NULL ? "" : row[12]),
196                               intro_len + 1);
197                    p_list->users[i].intro = p_list->user_intro_buf + intro_buf_offset;
198                    intro_buf_offset += (intro_len + 1);
199    
200                  i++;                  i++;
201                  if (i >= BBS_max_user_count)                  if (i >= BBS_max_user_count)
# Line 176  int user_list_load(MYSQL *db, USER_LIST Line 207  int user_list_load(MYSQL *db, USER_LIST
207          mysql_free_result(rs);          mysql_free_result(rs);
208          rs = NULL;          rs = NULL;
209    
210          p_list->user_count = i;          if (i != p_list->user_count || p_list->users[i - 1].uid != last_uid) // Count of users changed
211            {
212                    // Rebuild index
213                    for (j = 0; j < i; j++)
214                    {
215                            p_list->index_uid[j].uid = p_list->users[j].uid;
216                            p_list->index_uid[j].id = j;
217                    }
218    
219                    qsort(p_list->index_uid, (size_t)i, sizeof(USER_INFO_INDEX_UID), user_info_index_uid_comp);
220    
221    #ifdef _DEBUG
222                    log_error("Rebuild index of %d users, last_uid=%d\n", i, p_list->users[i - 1].uid);
223    #endif
224            }
225    
226          // Sort index          p_list->user_count = i;
         qsort(p_list->index_uid, (size_t)i, sizeof(USER_INFO_INDEX_UID), user_info_index_uid_comp);  
227    
228  #ifdef _DEBUG  #ifdef _DEBUG
229          log_error("Loaded %d users\n", p_list->user_count);          log_error("Loaded %d users\n", p_list->user_count);
# Line 191  cleanup: Line 235  cleanup:
235          return ret;          return ret;
236  }  }
237    
238  int user_online_list_load(MYSQL *db, USER_ONLINE_LIST *p_list)  int user_online_list_load(MYSQL *db, USER_ONLINE_LIST *p_online_list)
239  {  {
240          MYSQL_RES *rs = NULL;          MYSQL_RES *rs = NULL;
241          MYSQL_ROW row;          MYSQL_ROW row;
242          char sql[SQL_BUFFER_LEN];          char sql[SQL_BUFFER_LEN];
243          int ret = 0;          int ret = 0;
244          int i;          int i;
245            int j;
246            int user_cnt;
247            int guest_cnt;
248    
249          if (db == NULL || p_list == NULL)          if (db == NULL || p_online_list == NULL)
250          {          {
251                  log_error("NULL pointer error\n");                  log_error("NULL pointer error\n");
252                  return -1;                  return -1;
# Line 227  int user_online_list_load(MYSQL *db, USE Line 274  int user_online_list_load(MYSQL *db, USE
274          }          }
275    
276          i = 0;          i = 0;
277            user_cnt = 0;
278            guest_cnt = 0;
279          while ((row = mysql_fetch_row(rs)))          while ((row = mysql_fetch_row(rs)))
280          {          {
281                  p_list->users[i].id = i;                  if (atoi(row[1]) == 0) // guest
                 strncpy(p_list->users[i].session_id, row[0], sizeof(p_list->users[i].session_id) - 1);  
                 p_list->users[i].session_id[sizeof(p_list->users[i].session_id) - 1] = '\0';  
   
                 if ((ret = query_user_info_by_uid(atoi(row[1]), &(p_list->users[i].user_info))) < 0)  
282                  {                  {
283                          log_error("query_user_info(%d) error\n", atoi(row[1]));                          guest_cnt++;
284                          continue;                          continue;
285                  }                  }
286                  else if (ret == 0) // Guest                  else
287                  {                  {
288                          p_list->users[i].user_info.id = -1;                          user_cnt++;
289                          p_list->users[i].user_info.uid = 0;                  }
290                          strncpy(p_list->users[i].user_info.username, "guest", sizeof(p_list->users[i].user_info.username) - 1);  
291                          p_list->users[i].user_info.username[sizeof(p_list->users[i].user_info.username) - 1] = '\0';                  p_online_list->users[i].id = i;
292                          strncpy(p_list->users[i].user_info.nickname, "Guest", sizeof(p_list->users[i].user_info.nickname) - 1);                  strncpy(p_online_list->users[i].session_id, row[0], sizeof(p_online_list->users[i].session_id) - 1);
293                          p_list->users[i].user_info.nickname[sizeof(p_list->users[i].user_info.nickname) - 1] = '\0';                  p_online_list->users[i].session_id[sizeof(p_online_list->users[i].session_id) - 1] = '\0';
294                          p_list->users[i].user_info.gender = 'M';  
295                          p_list->users[i].user_info.gender_pub = 0;                  if ((ret = query_user_info_by_uid(atoi(row[1]), &(p_online_list->users[i].user_info), NULL, 0)) <= 0)
                         p_list->users[i].user_info.life = 150;  
                         p_list->users[i].user_info.exp = 0;  
                         p_list->users[i].user_info.signup_dt = 0;  
                         p_list->users[i].user_info.last_login_dt = 0;  
                         p_list->users[i].user_info.birthday = 0;  
                 }  
   
                 strncpy(p_list->users[i].ip, row[2], sizeof(p_list->users[i].ip) - 1);  
                 p_list->users[i].ip[sizeof(p_list->users[i].ip) - 1] = '\0';  
   
                 strncpy(p_list->users[i].current_action, row[3], sizeof(p_list->users[i].current_action) - 1);  
                 p_list->users[i].current_action[sizeof(p_list->users[i].current_action) - 1] = '\0';  
                 p_list->users[i].current_action_title = NULL;  
                 if (p_list->users[i].current_action[0] == '\0')  
296                  {                  {
297                          p_list->users[i].current_action_title = "";                          log_error("query_user_info_by_uid(%d) error\n", atoi(row[1]));
298                            continue;
299                  }                  }
300                  else if (trie_dict_get(p_trie_action_dict, p_list->users[i].current_action, (int64_t *)(&(p_list->users[i].current_action_title))) < 0)  
301                    strncpy(p_online_list->users[i].ip, row[2], sizeof(p_online_list->users[i].ip) - 1);
302                    p_online_list->users[i].ip[sizeof(p_online_list->users[i].ip) - 1] = '\0';
303    
304                    strncpy(p_online_list->users[i].current_action, row[3], sizeof(p_online_list->users[i].current_action) - 1);
305                    p_online_list->users[i].current_action[sizeof(p_online_list->users[i].current_action) - 1] = '\0';
306                    p_online_list->users[i].current_action_title = NULL;
307                    if (p_online_list->users[i].current_action[0] == '\0')
308                    {
309                            p_online_list->users[i].current_action_title = "";
310                    }
311                    else if (trie_dict_get(p_trie_action_dict, p_online_list->users[i].current_action, (int64_t *)(&(p_online_list->users[i].current_action_title))) < 0)
312                  {                  {
313                          log_error("trie_dict_get(p_trie_action_dict, %s) error on session_id=%s\n",                          log_error("trie_dict_get(p_trie_action_dict, %s) error on session_id=%s\n",
314                                            p_list->users[i].current_action, p_list->users[i].session_id);                                            p_online_list->users[i].current_action, p_online_list->users[i].session_id);
315                          continue;                          continue;
316                  }                  }
317    
318                  p_list->users[i].login_tm = (row[4] == NULL ? 0 : atol(row[4]));                  p_online_list->users[i].login_tm = (row[4] == NULL ? 0 : atol(row[4]));
319                  p_list->users[i].last_tm = (row[5] == NULL ? 0 : atol(row[5]));                  p_online_list->users[i].last_tm = (row[5] == NULL ? 0 : atol(row[5]));
320    
321                  i++;                  i++;
322                  if (i >= BBS_max_user_online_count)                  if (i >= BBS_max_user_online_count)
# Line 285  int user_online_list_load(MYSQL *db, USE Line 328  int user_online_list_load(MYSQL *db, USE
328          mysql_free_result(rs);          mysql_free_result(rs);
329          rs = NULL;          rs = NULL;
330    
331          p_list->user_count = i;          if (user_cnt > 0)
332            {
333                    // Rebuild index
334                    for (j = 0; j < user_cnt; j++)
335                    {
336                            p_online_list->index_uid[j].uid = p_online_list->users[j].user_info.uid;
337                            p_online_list->index_uid[j].id = j;
338                    }
339    
340  #ifdef _DEBUG                  qsort(p_online_list->index_uid, (size_t)user_cnt, sizeof(USER_INFO_INDEX_UID), user_info_index_uid_comp);
341          log_error("Loaded %d users\n", p_list->user_count);          }
342  #endif  
343            p_online_list->user_count = user_cnt;
344            p_online_list->guest_count = guest_cnt;
345    
346  cleanup:  cleanup:
347          mysql_free_result(rs);          mysql_free_result(rs);
# Line 297  cleanup: Line 349  cleanup:
349          return ret;          return ret;
350  }  }
351    
352  int user_list_pool_init(void)  int user_login_count_load(MYSQL *db)
353    {
354            MYSQL_RES *rs = NULL;
355            MYSQL_ROW row;
356            char sql[SQL_BUFFER_LEN];
357    
358            if (db == NULL)
359            {
360                    log_error("NULL pointer error\n");
361                    return -1;
362            }
363    
364            snprintf(sql, sizeof(sql),
365                             "SELECT ID FROM user_login_log ORDER BY ID DESC LIMIT 1");
366            if (mysql_query(db, sql) != 0)
367            {
368                    log_error("Query user_login_log error: %s\n", mysql_error(db));
369                    return -2;
370            }
371            if ((rs = mysql_store_result(db)) == NULL)
372            {
373                    log_error("Get user_login_log data failed\n");
374                    return -2;
375            }
376            if ((row = mysql_fetch_row(rs)))
377            {
378                    p_user_list_pool->user_login_count = atoi(row[0]);
379            }
380            mysql_free_result(rs);
381    
382            return 0;
383    }
384    
385    int user_list_pool_init(const char *filename)
386  {  {
387          int shmid;          int shmid;
388          int semid;          int semid;
# Line 331  int user_list_pool_init(void) Line 416  int user_list_pool_init(void)
416    
417          // Allocate shared memory          // Allocate shared memory
418          proj_id = (int)(time(NULL) % getpid());          proj_id = (int)(time(NULL) % getpid());
419          key = ftok(VAR_USER_LIST_SHM, proj_id);          key = ftok(filename, proj_id);
420          if (key == -1)          if (key == -1)
421          {          {
422                  log_error("ftok(%s %d) error (%d)\n", VAR_USER_LIST_SHM, proj_id, errno);                  log_error("ftok(%s %d) error (%d)\n", filename, proj_id, errno);
423                  return -2;                  return -2;
424          }          }
425    
# Line 387  int user_list_pool_init(void) Line 472  int user_list_pool_init(void)
472          p_user_list_pool->p_online_current = &(p_user_list_pool->user_online_list[0]);          p_user_list_pool->p_online_current = &(p_user_list_pool->user_online_list[0]);
473          p_user_list_pool->p_online_new = &(p_user_list_pool->user_online_list[1]);          p_user_list_pool->p_online_new = &(p_user_list_pool->user_online_list[1]);
474    
475            user_stat_map_init(&(p_user_list_pool->user_stat_map));
476    
477          return 0;          return 0;
478  }  }
479    
# Line 411  void user_list_pool_cleanup(void) Line 498  void user_list_pool_cleanup(void)
498                  log_error("shmdt(shmid = %d) error (%d)\n", shmid, errno);                  log_error("shmdt(shmid = %d) error (%d)\n", shmid, errno);
499          }          }
500    
501          if (shmctl(shmid, IPC_RMID, NULL) == -1)          if (shmid != 0 && shmctl(shmid, IPC_RMID, NULL) == -1)
502          {          {
503                  log_error("shmctl(shmid = %d, IPC_RMID) error (%d)\n", shmid, errno);                  log_error("shmctl(shmid = %d, IPC_RMID) error (%d)\n", shmid, errno);
504          }          }
# Line 470  int user_list_pool_reload(int online_use Line 557  int user_list_pool_reload(int online_use
557          MYSQL *db = NULL;          MYSQL *db = NULL;
558          USER_LIST *p_tmp;          USER_LIST *p_tmp;
559          USER_ONLINE_LIST *p_online_tmp;          USER_ONLINE_LIST *p_online_tmp;
560            int ret = 0;
561    
562          if (p_user_list_pool == NULL)          if (p_user_list_pool == NULL)
563          {          {
# Line 489  int user_list_pool_reload(int online_use Line 577  int user_list_pool_reload(int online_use
577                  if (user_online_list_load(db, p_user_list_pool->p_online_new) < 0)                  if (user_online_list_load(db, p_user_list_pool->p_online_new) < 0)
578                  {                  {
579                          log_error("user_online_list_load() error\n");                          log_error("user_online_list_load() error\n");
580                          return -2;                          ret = -2;
581                            goto cleanup;
582                    }
583    
584                    if (user_login_count_load(db) < 0)
585                    {
586                            log_error("user_login_count_load() error\n");
587                            ret = -2;
588                            goto cleanup;
589                  }                  }
590          }          }
591          else          else
# Line 497  int user_list_pool_reload(int online_use Line 593  int user_list_pool_reload(int online_use
593                  if (user_list_load(db, p_user_list_pool->p_new) < 0)                  if (user_list_load(db, p_user_list_pool->p_new) < 0)
594                  {                  {
595                          log_error("user_list_load() error\n");                          log_error("user_list_load() error\n");
596                          return -2;                          ret = -2;
597                            goto cleanup;
598                  }                  }
599          }          }
600    
601          mysql_close(db);          mysql_close(db);
602            db = NULL;
603    
604          if (user_list_rw_lock(p_user_list_pool->semid) < 0)          if (user_list_rw_lock(p_user_list_pool->semid) < 0)
605          {          {
606                  log_error("user_list_rw_lock() error\n");                  log_error("user_list_rw_lock() error\n");
607                  return -3;                  ret = -3;
608                    goto cleanup;
609          }          }
610    
611          if (online_user)          if (online_user)
# Line 527  int user_list_pool_reload(int online_use Line 626  int user_list_pool_reload(int online_use
626          if (user_list_rw_unlock(p_user_list_pool->semid) < 0)          if (user_list_rw_unlock(p_user_list_pool->semid) < 0)
627          {          {
628                  log_error("user_list_rw_unlock() error\n");                  log_error("user_list_rw_unlock() error\n");
629                  return -3;                  ret = -3;
630                    goto cleanup;
631          }          }
632    
633          return 0;  cleanup:
634            mysql_close(db);
635    
636            return ret;
637  }  }
638    
639  int user_list_try_rd_lock(int semid, int wait_sec)  int user_list_try_rd_lock(int semid, int wait_sec)
# Line 695  int query_user_list(int page_id, USER_IN Line 798  int query_user_list(int page_id, USER_IN
798                  return -1;                  return -1;
799          }          }
800    
801            *p_user_count = 0;
802            *p_page_count = 0;
803    
804          // acquire lock of user list          // acquire lock of user list
805          if (user_list_rd_lock(p_user_list_pool->semid) < 0)          if (user_list_rd_lock(p_user_list_pool->semid) < 0)
806          {          {
# Line 748  int query_user_online_list(int page_id, Line 854  int query_user_online_list(int page_id,
854                  return -1;                  return -1;
855          }          }
856    
857            *p_user_count = 0;
858            *p_page_count = 0;
859    
860          // acquire lock of user list          // acquire lock of user list
861          if (user_list_rd_lock(p_user_list_pool->semid) < 0)          if (user_list_rd_lock(p_user_list_pool->semid) < 0)
862          {          {
# Line 791  cleanup: Line 900  cleanup:
900          return ret;          return ret;
901  }  }
902    
903    int get_user_list_count(int *p_user_cnt)
904    {
905            if (p_user_cnt == NULL)
906            {
907                    log_error("NULL pointer error\n");
908                    return -1;
909            }
910    
911            // acquire lock of user list
912            if (user_list_rd_lock(p_user_list_pool->semid) < 0)
913            {
914                    log_error("user_list_rd_lock() error\n");
915                    return -2;
916            }
917    
918            *p_user_cnt = p_user_list_pool->p_current->user_count;
919    
920            // release lock of user list
921            if (user_list_rd_unlock(p_user_list_pool->semid) < 0)
922            {
923                    log_error("user_list_rd_unlock() error\n");
924                    return -2;
925            }
926    
927            return 0;
928    }
929    
930    int get_user_online_list_count(int *p_user_cnt, int *p_guest_cnt)
931    {
932            if (p_user_cnt == NULL || p_guest_cnt == NULL)
933            {
934                    log_error("NULL pointer error\n");
935                    return -1;
936            }
937    
938            // acquire lock of user list
939            if (user_list_rd_lock(p_user_list_pool->semid) < 0)
940            {
941                    log_error("user_list_rd_lock() error\n");
942                    return -2;
943            }
944    
945            *p_user_cnt = p_user_list_pool->p_online_current->user_count;
946            *p_guest_cnt = p_user_list_pool->p_online_current->guest_count;
947    
948            // release lock of user list
949            if (user_list_rd_unlock(p_user_list_pool->semid) < 0)
950            {
951                    log_error("user_list_rd_unlock() error\n");
952                    return -2;
953            }
954    
955            return 0;
956    }
957    
958    int get_user_login_count(int *p_login_cnt)
959    {
960            if (p_login_cnt == NULL)
961            {
962                    log_error("NULL pointer error\n");
963                    return -1;
964            }
965    
966            *p_login_cnt = p_user_list_pool->user_login_count;
967    
968            return 0;
969    }
970    
971  int query_user_info(int32_t id, USER_INFO *p_user)  int query_user_info(int32_t id, USER_INFO *p_user)
972  {  {
973          int ret = 0;          int ret = 0;
# Line 824  int query_user_info(int32_t id, USER_INF Line 1001  int query_user_info(int32_t id, USER_INF
1001          return ret;          return ret;
1002  }  }
1003    
1004  int query_user_info_by_uid(int32_t uid, USER_INFO *p_user)  int query_user_info_by_uid(int32_t uid, USER_INFO *p_user, char *p_intro_buf, size_t intro_buf_len)
1005  {  {
1006          int left;          int left;
1007          int right;          int right;
# Line 853  int query_user_info_by_uid(int32_t uid, Line 1030  int query_user_info_by_uid(int32_t uid,
1030                  mid = (left + right) / 2;                  mid = (left + right) / 2;
1031                  if (uid < p_user_list_pool->p_current->index_uid[mid].uid)                  if (uid < p_user_list_pool->p_current->index_uid[mid].uid)
1032                  {                  {
1033                          right = mid;                          right = mid - 1;
1034                  }                  }
1035                  else if (uid > p_user_list_pool->p_current->index_uid[mid].uid)                  else if (uid > p_user_list_pool->p_current->index_uid[mid].uid)
1036                  {                  {
# Line 869  int query_user_info_by_uid(int32_t uid, Line 1046  int query_user_info_by_uid(int32_t uid,
1046          if (uid == p_user_list_pool->p_current->index_uid[left].uid) // Found          if (uid == p_user_list_pool->p_current->index_uid[left].uid) // Found
1047          {          {
1048                  id = p_user_list_pool->p_current->index_uid[left].id;                  id = p_user_list_pool->p_current->index_uid[left].id;
1049                  if ((ret = query_user_info(id, p_user)) <= 0)                  *p_user = p_user_list_pool->p_current->users[id];
1050                    ret = 1;
1051    
1052                    if (p_intro_buf != NULL)
1053                  {                  {
1054                          log_error("query_user_info(id=%d) error: %d\n", id, ret);                          strncpy(p_intro_buf, p_user_list_pool->p_current->users[id].intro, intro_buf_len - 1);
1055                            p_intro_buf[intro_buf_len - 1] = '\0';
1056                            p_user->intro = p_intro_buf;
1057                  }                  }
1058                  else          }
1059    
1060            // release lock of user list
1061            if (user_list_rd_unlock(p_user_list_pool->semid) < 0)
1062            {
1063                    log_error("user_list_rd_unlock() error\n");
1064                    ret = -1;
1065            }
1066    
1067            return ret;
1068    }
1069    
1070    int query_user_info_by_username(const char *username_prefix, int max_user_cnt,
1071                                                                    int32_t uid_list[], char username_list[][BBS_username_max_len + 1])
1072    {
1073            int left;
1074            int right;
1075            int mid;
1076            int left_save;
1077            int ret = 0;
1078            size_t prefix_len;
1079            int comp;
1080            int i;
1081    
1082            if (username_prefix == NULL || uid_list == NULL || username_list == NULL)
1083            {
1084                    log_error("NULL pointer error\n");
1085                    return -1;
1086            }
1087    
1088            prefix_len = strlen(username_prefix);
1089    
1090            // acquire lock of user list
1091            if (user_list_rd_lock(p_user_list_pool->semid) < 0)
1092            {
1093                    log_error("user_list_rd_lock() error\n");
1094                    return -2;
1095            }
1096    
1097            left = 0;
1098            right = p_user_list_pool->p_current->user_count - 1;
1099    
1100            while (left < right)
1101            {
1102                    mid = (left + right) / 2;
1103                    comp = strncasecmp(username_prefix, p_user_list_pool->p_current->users[mid].username, prefix_len);
1104                    if (comp < 0)
1105                  {                  {
1106                          ret = 1;                          right = mid - 1;
1107                    }
1108                    else if (comp > 0)
1109                    {
1110                            left = mid + 1;
1111                    }
1112                    else // if (comp == 0)
1113                    {
1114                            left = mid;
1115                            break;
1116                  }                  }
1117          }          }
1118    
1119            if (strncasecmp(username_prefix, p_user_list_pool->p_current->users[left].username, prefix_len) == 0) // Found
1120            {
1121    #ifdef _DEBUG
1122                    log_error("Debug: match found, pos=%d\n", left);
1123    #endif
1124    
1125                    left_save = left;
1126                    right = left;
1127                    left = 0;
1128    
1129                    while (left < right)
1130                    {
1131                            mid = (left + right) / 2;
1132                            comp = strncasecmp(username_prefix, p_user_list_pool->p_current->users[mid].username, prefix_len);
1133                            if (comp > 0)
1134                            {
1135                                    left = mid + 1;
1136                            }
1137                            else if (comp == 0)
1138                            {
1139                                    right = mid;
1140                            }
1141                            else // if (comp < 0)
1142                            {
1143                                    log_error("Bug: left=%d right=%d mid=%d");
1144                                    ret = -2;
1145                                    goto cleanup;
1146                            }
1147                    }
1148    
1149    #ifdef _DEBUG
1150                    log_error("Debug: first match found, pos=%d\n", right);
1151    #endif
1152    
1153                    left = left_save;
1154                    left_save = right;
1155                    right = p_user_list_pool->p_current->user_count - 1;
1156    
1157                    while (left < right)
1158                    {
1159                            mid = (left + right) / 2 + (left + right) % 2;
1160                            comp = strncasecmp(username_prefix, p_user_list_pool->p_current->users[mid].username, prefix_len);
1161                            if (comp < 0)
1162                            {
1163                                    right = mid - 1;
1164                            }
1165                            else if (comp == 0)
1166                            {
1167                                    left = mid;
1168                            }
1169                            else // if (comp > 0)
1170                            {
1171                                    log_error("Bug: left=%d right=%d mid=%d");
1172                                    ret = -2;
1173                                    goto cleanup;
1174                            }
1175                    }
1176    
1177    #ifdef _DEBUG
1178                    log_error("Debug: last match found, pos=%d\n", left);
1179    #endif
1180    
1181                    right = left;
1182                    left = left_save;
1183    
1184                    for (i = 0; i < max_user_cnt && left + i <= right; i++)
1185                    {
1186                            uid_list[i] = p_user_list_pool->p_current->users[left + i].uid;
1187                            strncpy(username_list[i], p_user_list_pool->p_current->users[left + i].username, sizeof(username_list[i]) - 1);
1188                            username_list[i][sizeof(username_list[i]) - 1] = '\0';
1189                    }
1190                    ret = i;
1191            }
1192    
1193    cleanup:
1194          // release lock of user list          // release lock of user list
1195          if (user_list_rd_unlock(p_user_list_pool->semid) < 0)          if (user_list_rd_unlock(p_user_list_pool->semid) < 0)
1196          {          {
# Line 921  int query_user_online_info(int32_t id, U Line 1233  int query_user_online_info(int32_t id, U
1233    
1234          return ret;          return ret;
1235  }  }
1236    
1237    int query_user_online_info_by_uid(int32_t uid, USER_ONLINE_INFO *p_users, int *p_user_cnt, int start_id)
1238    {
1239            int left;
1240            int right;
1241            int mid;
1242            int32_t id;
1243            int ret = 0;
1244            int i;
1245            int user_cnt;
1246    
1247            if (p_users == NULL || p_user_cnt == NULL)
1248            {
1249                    log_error("NULL pointer error\n");
1250                    return -1;
1251            }
1252    
1253            user_cnt = *p_user_cnt;
1254            *p_user_cnt = 0;
1255    
1256            // acquire lock of user list
1257            if (user_list_rd_lock(p_user_list_pool->semid) < 0)
1258            {
1259                    log_error("user_list_rd_lock() error\n");
1260                    return -2;
1261            }
1262    
1263            left = start_id;
1264            right = p_user_list_pool->p_online_current->user_count - 1;
1265    
1266            while (left < right)
1267            {
1268                    mid = (left + right) / 2;
1269                    if (uid < p_user_list_pool->p_online_current->index_uid[mid].uid)
1270                    {
1271                            right = mid - 1;
1272                    }
1273                    else if (uid > p_user_list_pool->p_online_current->index_uid[mid].uid)
1274                    {
1275                            left = mid + 1;
1276                    }
1277                    else // if (uid == p_user_list_pool->p_online_current->index_uid[mid].uid)
1278                    {
1279                            left = mid;
1280                            break;
1281                    }
1282            }
1283    
1284            if (uid == p_user_list_pool->p_online_current->index_uid[left].uid)
1285            {
1286                    right = left;
1287                    left = start_id;
1288    
1289                    while (left < right)
1290                    {
1291                            mid = (left + right) / 2;
1292                            if (uid - 1 < p_user_list_pool->p_online_current->index_uid[mid].uid)
1293                            {
1294                                    right = mid;
1295                            }
1296                            else // if (uid - 1 >= p_user_list_pool->p_online_current->index_uid[mid].uid)
1297                            {
1298                                    left = mid + 1;
1299                            }
1300                    }
1301    
1302                    for (i = 0;
1303                             left < p_user_list_pool->p_online_current->user_count && i < user_cnt &&
1304                             uid == p_user_list_pool->p_online_current->index_uid[left].uid;
1305                             left++, i++)
1306                    {
1307                            id = p_user_list_pool->p_online_current->index_uid[left].id;
1308                            p_users[i] = p_user_list_pool->p_online_current->users[id];
1309                    }
1310    
1311                    if (i > 0)
1312                    {
1313                            *p_user_cnt = i;
1314                            ret = 1;
1315                    }
1316            }
1317    
1318            // release lock of user list
1319            if (user_list_rd_unlock(p_user_list_pool->semid) < 0)
1320            {
1321                    log_error("user_list_rd_unlock() error\n");
1322                    ret = -1;
1323            }
1324    
1325            return ret;
1326    }
1327    
1328    int get_user_id_list(int32_t *p_uid_list, int *p_user_cnt, int start_uid)
1329    {
1330            int left;
1331            int right;
1332            int mid;
1333            int ret = 0;
1334            int i;
1335    
1336            if (p_uid_list == NULL || p_user_cnt == NULL)
1337            {
1338                    log_error("NULL pointer error\n");
1339                    return -1;
1340            }
1341    
1342            // acquire lock of user list
1343            if (user_list_rd_lock(p_user_list_pool->semid) < 0)
1344            {
1345                    log_error("user_list_rd_lock() error\n");
1346                    return -2;
1347            }
1348    
1349            left = 0;
1350            right = p_user_list_pool->p_current->user_count - 1;
1351    
1352            while (left < right)
1353            {
1354                    mid = (left + right) / 2;
1355                    if (start_uid < p_user_list_pool->p_current->index_uid[mid].uid)
1356                    {
1357                            right = mid - 1;
1358                    }
1359                    else if (start_uid > p_user_list_pool->p_current->index_uid[mid].uid)
1360                    {
1361                            left = mid + 1;
1362                    }
1363                    else // if (start_uid == p_user_list_pool->p_current->index_uid[mid].uid)
1364                    {
1365                            left = mid;
1366                            break;
1367                    }
1368            }
1369    
1370            for (i = 0; i < *p_user_cnt && left + i < p_user_list_pool->p_current->user_count; i++)
1371            {
1372                    p_uid_list[i] = p_user_list_pool->p_current->index_uid[left + i].uid;
1373            }
1374            *p_user_cnt = i;
1375    
1376            // release lock of user list
1377            if (user_list_rd_unlock(p_user_list_pool->semid) < 0)
1378            {
1379                    log_error("user_list_rd_unlock() error\n");
1380                    ret = -1;
1381            }
1382    
1383            return ret;
1384    }
1385    
1386    int user_stat_update(void)
1387    {
1388            return user_stat_map_update(&(p_user_list_pool->user_stat_map));
1389    }
1390    
1391    int user_article_cnt_inc(int32_t uid, int n)
1392    {
1393            return user_stat_article_cnt_inc(&(p_user_list_pool->user_stat_map), uid, n);
1394    }
1395    
1396    int get_user_article_cnt(int32_t uid)
1397    {
1398            const USER_STAT *p_stat;
1399            int ret;
1400    
1401            ret = user_stat_get(&(p_user_list_pool->user_stat_map), uid, &p_stat);
1402            if (ret < 0)
1403            {
1404                    log_error("user_stat_get(uid=%d) error: %d\n", uid, ret);
1405                    return -1;
1406            }
1407            else if (ret == 0) // user not found
1408            {
1409                    return -1;
1410            }
1411    
1412            return p_stat->article_count;
1413    }

Legend:
Removed lines/characters  
Changed lines/characters
  Added lines/characters
webmaster@leafok.com
 ViewVC Help
Powered by ViewVC 1.3.0-beta1