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 void
 117 userlist_set_account (struct session *sess, char *nick, char *account)
 118 {
 119         struct User *user;
 120
 121         user = userlist_find (sess, nick);
 122         if (user)
 123         {
 124                 if (user->account)
 125                         free (user->account);
 126
 127                 if (strcmp (account, "*") == 0)
 128                         user->account = NULL;
 129                 else
 130                         user->account = strdup (account);
 131
 132                 /* gui doesnt currently reflect login status, maybe later
 133                 fe_userlist_rehash (sess, user); */
 134         }
 135 }
 136
 137 int
 138 userlist_add_hostname (struct session *sess, char *nick, char *hostname,
 139                                                           char *realname, char *servername, char *account, unsigned int away)
 140 {
 141         struct User *user;
 142
 143         user = userlist_find (sess, nick);
 144         if (user)
 145         {
 146                 if (!user->hostname && hostname)
 147                         user->hostname = strdup (hostname);
 148                 if (!user->realname && realname)
 149                         user->realname = strdup (realname);
 150                 if (!user->servername && servername)
 151                         user->servername = strdup (servername);
 152                 if (!user->account && account && strcmp (account, "0") != 0)
 153                         user->account = strdup (account);
 154
 155                 if (away != 0xff)
 156                 {
 157                         if (prefs.showhostname_in_userlist || user->away != away)
 158                         {
 159                                 user->away = away;
 160                                 fe_userlist_rehash (sess, user);
 161                         }
 162                         user->away = away;
 163                 }
 164
 165                 fe_userlist_update (sess, user);
 166
 167                 return 1;
 168         }
 169         return 0;
 170 }
 171
 172 static int
 173 free_user (struct User *user, gpointer data)
 174 {
 175         if (user->realname)
 176                 free (user->realname);
 177         if (user->hostname)
 178                 free (user->hostname);
 179         if (user->servername)
 180                 free (user->servername);
 181         if (user->account)
 182                 free (user->account);
 183         free (user);
 184
 185         return TRUE;
 186 }
 187
 188 void
 189 userlist_free (session *sess)
 190 {
 191         tree_foreach (sess->usertree, (tree_traverse_func *)free_user, NULL);
 192         tree_destroy (sess->usertree);
 193         tree_destroy (sess->usertree_alpha);
 194
 195         sess->usertree = NULL;
 196         sess->usertree_alpha = NULL;
 197         sess->me = NULL;
 198
 199         sess->ops = 0;
 200         sess->hops = 0;
 201         sess->voices = 0;
 202         sess->total = 0;
 203 }
 204
 205 void
 206 userlist_clear (session *sess)
 207 {
 208         fe_userlist_clear (sess);
 209         userlist_free (sess);
 210         fe_userlist_numbers (sess);
 211 }
 212
 213 static int
 214 find_cmp (const char *name, struct User *user, server *serv)
 215 {
 216         return serv->p_cmp ((char *)name, user->nick);
 217 }
 218
 219 struct User *
 220 userlist_find (struct session *sess, char *name)
 221 {
 222         int pos;
 223
 224         if (sess->usertree_alpha)
 225                 return tree_find (sess->usertree_alpha, name,
 226                                                                 (tree_cmp_func *)find_cmp, sess->server, &pos);
 227
 228         return NULL;
 229 }
 230
 231 struct User *
 232 userlist_find_global (struct server *serv, char *name)
 233 {
 234         struct User *user;
 235         session *sess;
 236         GSList *list = sess_list;
 237         while (list)
 238         {
 239                 sess = (session *) list->data;
 240                 if (sess->server == serv)
 241                 {
 242                         user = userlist_find (sess, name);
 243                         if (user)
 244                                 return user;
 245                 }
 246                 list = list->next;
 247         }
 248         return 0;
 249 }
 250
 251 static void
 252 update_counts (session *sess, struct User *user, char prefix,
 253                                         int level, int offset)
 254 {
 255         switch (prefix)
 256         {
 257         case '@':
 258                 user->op = level;
 259                 sess->ops += offset;
 260                 break;
 261         case '%':
 262                 user->hop = level;
 263                 sess->hops += offset;
 264                 break;
 265         case '+':
 266                 user->voice = level;
 267                 sess->voices += offset;
 268                 break;
 269         }
 270 }
 271
 272 void
 273 userlist_update_mode (session *sess, char *name, char mode, char sign)
 274 {
 275         int access;
 276         int offset = 0;
 277         int level;
 278         int pos;
 279         char prefix;
 280         struct User *user;
 281
 282         user = userlist_find (sess, name);
 283         if (!user)
 284                 return;
 285
 286         /* remove from binary trees, before we loose track of it */
 287         tree_remove (sess->usertree, user, &pos);
 288         tree_remove (sess->usertree_alpha, user, &pos);
 289
 290         /* which bit number is affected? */
 291         access = mode_access (sess->server, mode, &prefix);
 292
 293         if (sign == '+')
 294         {
 295                 level = TRUE;
 296                 if (!(user->access & (1 << access)))
 297                 {
 298                         offset = 1;
 299                         user->access |= (1 << access);
 300                 }
 301         } else
 302         {
 303                 level = FALSE;
 304                 if (user->access & (1 << access))
 305                 {
 306                         offset = -1;
 307                         user->access &= ~(1 << access);
 308                 }
 309         }
 310
 311         /* now what is this users highest prefix? e.g. @ for ops */
 312         user->prefix[0] = get_nick_prefix (sess->server, user->access);
 313
 314         /* update the various counts using the CHANGED prefix only */
 315         update_counts (sess, user, prefix, level, offset);
 316
 317         /* insert it back into its new place */
 318         tree_insert (sess->usertree_alpha, user);
 319         pos = tree_insert (sess->usertree, user);
 320
 321         /* let GTK move it too */
 322         fe_userlist_move (sess, user, pos);
 323         fe_userlist_numbers (sess);
 324 }
 325
 326 int
 327 userlist_change (struct session *sess, char *oldname, char *newname)
 328 {
 329         struct User *user = userlist_find (sess, oldname);
 330         int pos;
 331
 332         if (user)
 333         {
 334                 tree_remove (sess->usertree, user, &pos);
 335                 tree_remove (sess->usertree_alpha, user, &pos);
 336
 337                 safe_strcpy (user->nick, newname, NICKLEN);
 338
 339                 tree_insert (sess->usertree_alpha, user);
 340
 341                 fe_userlist_move (sess, user, tree_insert (sess->usertree, user));
 342                 fe_userlist_numbers (sess);
 343
 344                 return 1;
 345         }
 346
 347         return 0;
 348 }
 349
 350 int
 351 userlist_remove (struct session *sess, char *name)
 352 {
 353         struct User *user;
 354
 355         user = userlist_find (sess, name);
 356         if (!user)
 357                 return FALSE;
 358
 359         userlist_remove_user (sess, user);
 360         return TRUE;
 361 }
 362
 363 void
 364 userlist_remove_user (struct session *sess, struct User *user)
 365 {
 366         int pos;
 367         if (user->voice)
 368                 sess->voices--;
 369         if (user->op)
 370                 sess->ops--;
 371         if (user->hop)
 372                 sess->hops--;
 373         sess->total--;
 374         fe_userlist_numbers (sess);
 375         fe_userlist_remove (sess, user);
 376
 377         if (user == sess->me)
 378                 sess->me = NULL;
 379
 380         tree_remove (sess->usertree, user, &pos);
 381         tree_remove (sess->usertree_alpha, user, &pos);
 382         free_user (user, NULL);
 383 }
 384
 385 void
 386 userlist_add (struct session *sess, char *name, char *hostname, char *account, char *realname)
 387 {
 388         struct User *user;
 389         int row, prefix_chars;
 390         unsigned int acc;
 391
 392         acc = nick_access (sess->server, name, &prefix_chars);
 393
 394         notify_set_online (sess->server, name + prefix_chars);
 395
 396         user = malloc (sizeof (struct User));
 397         memset (user, 0, sizeof (struct User));
 398
 399         user->access = acc;
 400
 401         /* assume first char is the highest level nick prefix */
 402         if (prefix_chars)
 403                 user->prefix[0] = name[0];
 404
 405         /* add it to our linked list */
 406         if (hostname)
 407                 user->hostname = strdup (hostname);
 408         safe_strcpy (user->nick, name + prefix_chars, NICKLEN);
 409         /* is it me? */
 410         if (!sess->server->p_cmp (user->nick, sess->server->nick))
 411                 user->me = TRUE;
 412         /* extended join info */
 413         if (sess->server->have_extjoin)
 414         {
 415                 if (account && strcmp (account, "*") != 0)
 416                         user->account = strdup (account);
 417                 if (realname)
 418                         user->realname = strdup (realname);
 419         }
 420
 421         row = userlist_insertname (sess, user);
 422
 423         /* duplicate? some broken servers trigger this */
 424         if (row == -1)
 425         {
 426                 if (user->hostname)
 427                         free (user->hostname);
 428                 if (user->account)
 429                         free (user->account);
 430                 if (user->realname)
 431                         free (user->realname);
 432                 free (user);
 433                 return;
 434         }
 435
 436         sess->total++;
 437
 438         /* most ircds don't support multiple modechars infront of the nickname
 439       for /NAMES - though they should. */
 440         while (prefix_chars)
 441         {
 442                 update_counts (sess, user, name[0], TRUE, 1);
 443                 name++;
 444                 prefix_chars--;
 445         }
 446
 447         if (user->me)
 448                 sess->me = user;
 449
 450         fe_userlist_insert (sess, user, row, FALSE);
 451         fe_userlist_numbers (sess);
 452 }
 453
 454 static int
 455 rehash_cb (struct User *user, session *sess)
 456 {
 457         fe_userlist_rehash (sess, user);
 458         return TRUE;
 459 }
 460
 461 void
 462 userlist_rehash (session *sess)
 463 {
 464         tree_foreach (sess->usertree_alpha, (tree_traverse_func *)rehash_cb, sess);
 465 }
 466
 467 static int
 468 flat_cb (struct User *user, GSList **list)
 469 {
 470         *list = g_slist_prepend (*list, user);
 471         return TRUE;
 472 }
 473
 474 GSList *
 475 userlist_flat_list (session *sess)
 476 {
 477         GSList *list = NULL;
 478
 479         tree_foreach (sess->usertree_alpha, (tree_traverse_func *)flat_cb, &list);
 480         return g_slist_reverse (list);
 481 }
 482
 483 static int
 484 double_cb (struct User *user, GList **list)
 485 {
 486         *list = g_list_prepend(*list, user);
 487         return TRUE;
 488 }
 489
 490 GList *
 491 userlist_double_list(session *sess)
 492 {
 493         GList *list = NULL;
 494
 495         tree_foreach (sess->usertree_alpha, (tree_traverse_func *)double_cb, &list);
 496         return list;
 497 }