src/common/userlist.c

   1 /* X-Chat
   2  * Copyright (C) 1998 Peter Zelezny.
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (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
  19 #include <stdio.h>
  20 #include <stdlib.h>
  21 #include <string.h>
  22
  23 #include "xchat.h"
  24 #include "modes.h"
  25 #include "fe.h"
  26 #include "notify.h"
  27 #include "tree.h"
  28 #include "xchatc.h"
  29 #include "util.h"
  30
  31
  32 static int
  33 nick_cmp_az_ops (server *serv, struct User *user1, struct User *user2)
  34 {
  35         unsigned int access1 = user1->access;
  36         unsigned int access2 = user2->access;
  37         int pos;
  38
  39         if (access1 != access2)
  40         {
  41                 for (pos = 0; pos < USERACCESS_SIZE; pos++)
  42                 {
  43                         if ((access1&(1<<pos)) && (access2&(1<<pos)))
  44                                 break;
  45                         if ((access1&(1<<pos)) && !(access2&(1<<pos)))
  46                                 return -1;
  47                         if (!(access1&(1<<pos)) && (access2&(1<<pos)))
  48                                 return 1;
  49                 }
  50         }
  51
  52         return serv->p_cmp (user1->nick, user2->nick);
  53 }
  54
  55 static int
  56 nick_cmp_alpha (struct User *user1, struct User *user2, server *serv)
  57 {
  58         return serv->p_cmp (user1->nick, user2->nick);
  59 }
  60
  61 static int
  62 nick_cmp (struct User *user1, struct User *user2, server *serv)
  63 {
  64         switch (prefs.userlist_sort)
  65         {
  66         case 0:
  67                 return nick_cmp_az_ops (serv, user1, user2);
  68         case 1:
  69                 return serv->p_cmp (user1->nick, user2->nick);
  70         case 2:
  71                 return -1 * nick_cmp_az_ops (serv, user1, user2);
  72         case 3:
  73                 return -1 * serv->p_cmp (user1->nick, user2->nick);
  74         default:
  75                 return -1;
  76         }
  77 }
  78
  79 /*
  80  insert name in appropriate place in linked list. Returns row number or:
  81   -1: duplicate
  82 */
  83
  84 static int
  85 userlist_insertname (session *sess, struct User *newuser)
  86 {
  87         if (!sess->usertree)
  88         {
  89                 sess->usertree = tree_new ((tree_cmp_func *)nick_cmp, sess->server);
  90                 sess->usertree_alpha = tree_new ((tree_cmp_func *)nick_cmp_alpha, sess->server);
  91         }
  92
  93         tree_insert (sess->usertree_alpha, newuser);
  94         return tree_insert (sess->usertree, newuser);
  95 }
  96
  97 void
  98 userlist_set_away (struct session *sess, char *nick, unsigned int away)
  99 {
 100         struct User *user;
 101
 102         user = userlist_find (sess, nick);
 103         if (user)
 104         {
 105                 if (user->away != away)
 106                 {
 107                         user->away = away;
 108                         /* rehash GUI */
 109                         fe_userlist_rehash (sess, user);
 110                         if (away)
 111                                 fe_userlist_update (sess, user);
 112                 }
 113         }
 114 }
 115
 116 int
 117 userlist_add_hostname (struct session *sess, char *nick, char *hostname,
 118                                                           char *realname, char *servername, unsigned int away)
 119 {
 120         struct User *user;
 121
 122         user = userlist_find (sess, nick);
 123         if (user)
 124         {
 125                 if (!user->hostname && hostname)
 126                         user->hostname = strdup (hostname);
 127                 if (!user->realname && realname)
 128                         user->realname = strdup (realname);
 129                 if (!user->servername && servername)
 130                         user->servername = strdup (servername);
 131
 132                 if (away != 0xff)
 133                 {
 134                         if (prefs.showhostname_in_userlist || user->away != away)
 135                         {
 136                                 user->away = away;
 137                                 fe_userlist_rehash (sess, user);
 138                         }
 139                         user->away = away;
 140                 }
 141
 142                 fe_userlist_update (sess, user);
 143
 144                 return 1;
 145         }
 146         return 0;
 147 }
 148
 149 static int
 150 free_user (struct User *user, gpointer data)
 151 {
 152         if (user->realname)
 153                 free (user->realname);
 154         if (user->hostname)
 155                 free (user->hostname);
 156         if (user->servername)
 157                 free (user->servername);
 158         free (user);
 159
 160         return TRUE;
 161 }
 162
 163 void
 164 userlist_free (session *sess)
 165 {
 166         tree_foreach (sess->usertree, (tree_traverse_func *)free_user, NULL);
 167         tree_destroy (sess->usertree);
 168         tree_destroy (sess->usertree_alpha);
 169
 170         sess->usertree = NULL;
 171         sess->usertree_alpha = NULL;
 172         sess->me = NULL;
 173
 174         sess->ops = 0;
 175         sess->hops = 0;
 176         sess->voices = 0;
 177         sess->total = 0;
 178 }
 179
 180 void
 181 userlist_clear (session *sess)
 182 {
 183         fe_userlist_clear (sess);
 184         userlist_free (sess);
 185         fe_userlist_numbers (sess);
 186 }
 187
 188 static int
 189 find_cmp (const char *name, struct User *user, server *serv)
 190 {
 191         return serv->p_cmp ((char *)name, user->nick);
 192 }
 193
 194 struct User *
 195 userlist_find (struct session *sess, char *name)
 196 {
 197         int pos;
 198
 199         if (sess->usertree_alpha)
 200                 return tree_find (sess->usertree_alpha, name,
 201                                                                 (tree_cmp_func *)find_cmp, sess->server, &pos);
 202
 203         return NULL;
 204 }
 205
 206 struct User *
 207 userlist_find_global (struct server *serv, char *name)
 208 {
 209         struct User *user;
 210         session *sess;
 211         GSList *list = sess_list;
 212         while (list)
 213         {
 214                 sess = (session *) list->data;
 215                 if (sess->server == serv)
 216                 {
 217                         user = userlist_find (sess, name);
 218                         if (user)
 219                                 return user;
 220                 }
 221                 list = list->next;
 222         }
 223         return 0;
 224 }
 225
 226 static void
 227 update_counts (session *sess, struct User *user, char prefix,
 228                                         int level, int offset)
 229 {
 230         switch (prefix)
 231         {
 232         case '@':
 233                 user->op = level;
 234                 sess->ops += offset;
 235                 break;
 236         case '%':
 237                 user->hop = level;
 238                 sess->hops += offset;
 239                 break;
 240         case '+':
 241                 user->voice = level;
 242                 sess->voices += offset;
 243                 break;
 244         }
 245 }
 246
 247 void
 248 userlist_update_mode (session *sess, char *name, char mode, char sign)
 249 {
 250         int access;
 251         int offset = 0;
 252         int level;
 253         int pos;
 254         char prefix;
 255         struct User *user;
 256
 257         user = userlist_find (sess, name);
 258         if (!user)
 259                 return;
 260
 261         /* remove from binary trees, before we loose track of it */
 262         tree_remove (sess->usertree, user, &pos);
 263         tree_remove (sess->usertree_alpha, user, &pos);
 264
 265         /* which bit number is affected? */
 266         access = mode_access (sess->server, mode, &prefix);
 267
 268         if (sign == '+')
 269         {
 270                 level = TRUE;
 271                 if (!(user->access & (1 << access)))
 272                 {
 273                         offset = 1;
 274                         user->access |= (1 << access);
 275                 }
 276         } else
 277         {
 278                 level = FALSE;
 279                 if (user->access & (1 << access))
 280                 {
 281                         offset = -1;
 282                         user->access &= ~(1 << access);
 283                 }
 284         }
 285
 286         /* now what is this users highest prefix? e.g. @ for ops */
 287         user->prefix[0] = get_nick_prefix (sess->server, user->access);
 288
 289         /* update the various counts using the CHANGED prefix only */
 290         update_counts (sess, user, prefix, level, offset);
 291
 292         /* insert it back into its new place */
 293         tree_insert (sess->usertree_alpha, user);
 294         pos = tree_insert (sess->usertree, user);
 295
 296         /* let GTK move it too */
 297         fe_userlist_move (sess, user, pos);
 298         fe_userlist_numbers (sess);
 299 }
 300
 301 int
 302 userlist_change (struct session *sess, char *oldname, char *newname)
 303 {
 304         struct User *user = userlist_find (sess, oldname);
 305         int pos;
 306
 307         if (user)
 308         {
 309                 tree_remove (sess->usertree, user, &pos);
 310                 tree_remove (sess->usertree_alpha, user, &pos);
 311
 312                 safe_strcpy (user->nick, newname, NICKLEN);
 313
 314                 tree_insert (sess->usertree_alpha, user);
 315
 316                 fe_userlist_move (sess, user, tree_insert (sess->usertree, user));
 317                 fe_userlist_numbers (sess);
 318
 319                 return 1;
 320         }
 321
 322         return 0;
 323 }
 324
 325 int
 326 userlist_remove (struct session *sess, char *name)
 327 {
 328         struct User *user;
 329
 330         user = userlist_find (sess, name);
 331         if (!user)
 332                 return FALSE;
 333
 334         userlist_remove_user (sess, user);
 335         return TRUE;
 336 }
 337
 338 void
 339 userlist_remove_user (struct session *sess, struct User *user)
 340 {
 341         int pos;
 342         if (user->voice)
 343                 sess->voices--;
 344         if (user->op)
 345                 sess->ops--;
 346         if (user->hop)
 347                 sess->hops--;
 348         sess->total--;
 349         fe_userlist_numbers (sess);
 350         fe_userlist_remove (sess, user);
 351
 352         if (user == sess->me)
 353                 sess->me = NULL;
 354
 355         tree_remove (sess->usertree, user, &pos);
 356         tree_remove (sess->usertree_alpha, user, &pos);
 357         free_user (user, NULL);
 358 }
 359
 360 void
 361 userlist_add (struct session *sess, char *name, char *hostname)
 362 {
 363         struct User *user;
 364         int row, prefix_chars;
 365         unsigned int acc;
 366
 367         acc = nick_access (sess->server, name, &prefix_chars);
 368
 369         notify_set_online (sess->server, name + prefix_chars);
 370
 371         user = malloc (sizeof (struct User));
 372         memset (user, 0, sizeof (struct User));
 373
 374         user->access = acc;
 375
 376         /* assume first char is the highest level nick prefix */
 377         if (prefix_chars)
 378                 user->prefix[0] = name[0];
 379
 380         /* add it to our linked list */
 381         if (hostname)
 382                 user->hostname = strdup (hostname);
 383         safe_strcpy (user->nick, name + prefix_chars, NICKLEN);
 384         /* is it me? */
 385         if (!sess->server->p_cmp (user->nick, sess->server->nick))
 386                 user->me = TRUE;
 387         row = userlist_insertname (sess, user);
 388
 389         /* duplicate? some broken servers trigger this */
 390         if (row == -1)
 391         {
 392                 if (user->hostname)
 393                         free (user->hostname);
 394                 free (user);
 395                 return;
 396         }
 397
 398         sess->total++;
 399
 400         /* most ircds don't support multiple modechars infront of the nickname
 401       for /NAMES - though they should. */
 402         while (prefix_chars)
 403         {
 404                 update_counts (sess, user, name[0], TRUE, 1);
 405                 name++;
 406                 prefix_chars--;
 407         }
 408
 409         if (user->me)
 410                 sess->me = user;
 411
 412         fe_userlist_insert (sess, user, row, FALSE);
 413         fe_userlist_numbers (sess);
 414 }
 415
 416 static int
 417 rehash_cb (struct User *user, session *sess)
 418 {
 419         fe_userlist_rehash (sess, user);
 420         return TRUE;
 421 }
 422
 423 void
 424 userlist_rehash (session *sess)
 425 {
 426         tree_foreach (sess->usertree_alpha, (tree_traverse_func *)rehash_cb, sess);
 427 }
 428
 429 static int
 430 flat_cb (struct User *user, GSList **list)
 431 {
 432         *list = g_slist_prepend (*list, user);
 433         return TRUE;
 434 }
 435
 436 GSList *
 437 userlist_flat_list (session *sess)
 438 {
 439         GSList *list = NULL;
 440
 441         tree_foreach (sess->usertree_alpha, (tree_traverse_func *)flat_cb, &list);
 442         return g_slist_reverse (list);
 443 }
 444
 445 static int
 446 double_cb (struct User *user, GList **list)
 447 {
 448         *list = g_list_prepend(*list, user);
 449         return TRUE;
 450 }
 451
 452 GList *
 453 userlist_double_list(session *sess)
 454 {
 455         GList *list = NULL;
 456
 457         tree_foreach (sess->usertree_alpha, (tree_traverse_func *)double_cb, &list);
 458         return list;
 459 }