src/server.c

   1 /*
   2  * gaim
   3  *
   4  * Copyright (C) 1998-1999, Mark Spencer <markster@marko.net>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  *
  20  */
  21
  22 #ifdef HAVE_CONFIG_H
  23 #include <config.h>
  24 #endif
  25 #include <time.h>
  26 #include <stdio.h>
  27 #include <stdlib.h>
  28 #include <string.h>
  29 #include <sys/types.h>
  30 #include <sys/stat.h>
  31 #include <sys/time.h>
  32 #include <unistd.h>
  33 #include <errno.h>
  34 #include "gtkimhtml.h"
  35 #include "prpl.h"
  36 #include "multi.h"
  37 #include "gaim.h"
  38 #include "sound.h"
  39 #include "pounce.h"
  40 #include "notify.h"
  41
  42 void serv_login(struct gaim_account *account)
  43 {
  44         GaimPlugin *p = gaim_find_prpl(account->protocol);
  45         GaimPluginProtocolInfo *prpl_info = NULL;
  46
  47         if (account->gc != NULL || p == NULL)
  48                 return;
  49
  50         prpl_info = GAIM_PLUGIN_PROTOCOL_INFO(p);
  51
  52         if (prpl_info->login) {
  53                 if (!strlen(account->password) && !(prpl_info->options & OPT_PROTO_NO_PASSWORD) &&
  54                         !(prpl_info->options & OPT_PROTO_PASSWORD_OPTIONAL)) {
  55                         gaim_notify_error(NULL, NULL,
  56                                                           _("Please enter your password"), NULL);
  57                         return;
  58                 }
  59
  60                 gaim_debug(GAIM_DEBUG_INFO, "server",
  61                                    PACKAGE " " VERSION " logging in %s using %s\n",
  62                                    account->username, p->info->name);
  63                 account->connecting = TRUE;
  64                 connecting_count++;
  65                 gaim_debug(GAIM_DEBUG_MISC, "server",
  66                                    "connection count: %d\n", connecting_count);
  67                 gaim_event_broadcast(event_connecting, account);
  68                 prpl_info->login(account);
  69         }
  70 }
  71
  72 static gboolean send_keepalive(gpointer d)
  73 {
  74         struct gaim_connection *gc = d;
  75         GaimPluginProtocolInfo *prpl_info = NULL;
  76
  77         if (gc != NULL && gc->prpl != NULL)
  78                 prpl_info = GAIM_PLUGIN_PROTOCOL_INFO(gc->prpl);
  79
  80         if (prpl_info && prpl_info->keepalive)
  81                 prpl_info->keepalive(gc);
  82
  83         return TRUE;
  84 }
  85
  86 static void update_keepalive(struct gaim_connection *gc, gboolean on)
  87 {
  88         if (on && !gc->keepalive) {
  89                 gaim_debug(GAIM_DEBUG_INFO, "server", "allowing NOP\n");
  90                 gc->keepalive = g_timeout_add(60000, send_keepalive, gc);
  91         } else if (!on && gc->keepalive > 0) {
  92                 gaim_debug(GAIM_DEBUG_INFO, "server", "removing NOP\n");
  93                 g_source_remove(gc->keepalive);
  94                 gc->keepalive = 0;
  95         }
  96 }
  97
  98 void serv_close(struct gaim_connection *gc)
  99 {
 100         GaimPlugin *prpl;
 101         GaimPluginProtocolInfo *prpl_info = NULL;
 102
 103         while (gc->buddy_chats) {
 104                 struct gaim_conversation *b = gc->buddy_chats->data;
 105
 106                 gc->buddy_chats = g_slist_remove(gc->buddy_chats, b);
 107
 108                 /* TODO: Nuke the UI-specific code here. */
 109                 if (GAIM_IS_GTK_CONVERSATION(b))
 110                         gaim_gtkconv_update_buttons_by_protocol(b);
 111         }
 112
 113         if (gc->idle_timer > 0)
 114                 g_source_remove(gc->idle_timer);
 115         gc->idle_timer = 0;
 116
 117         update_keepalive(gc, FALSE);
 118
 119         if (gc->prpl != NULL) {
 120                 prpl_info = GAIM_PLUGIN_PROTOCOL_INFO(gc->prpl);
 121
 122                 if (prpl_info->close)
 123                         prpl_info->close(gc);
 124         }
 125
 126         prpl = gc->prpl;
 127         account_offline(gc);
 128         destroy_gaim_conn(gc);
 129 }
 130
 131 void serv_touch_idle(struct gaim_connection *gc)
 132 {
 133         /* Are we idle?  If so, not anymore */
 134         if (gc->is_idle > 0) {
 135                 gc->is_idle = 0;
 136                 serv_set_idle(gc, 0);
 137         }
 138         time(&gc->lastsent);
 139         if (gc->is_auto_away)
 140                 check_idle(gc);
 141 }
 142
 143 void serv_finish_login(struct gaim_connection *gc)
 144 {
 145         GaimPluginProtocolInfo *prpl_info = NULL;
 146
 147         if (gc != NULL && gc->prpl != NULL)
 148                 prpl_info = GAIM_PLUGIN_PROTOCOL_INFO(gc->prpl);
 149
 150         if (strlen(gc->account->user_info)) {
 151                 /* g_malloc(strlen(gc->user->user_info) * 4);
 152                    strncpy_withhtml(buf, gc->user->user_info, strlen(gc->user->user_info) * 4); */
 153                 serv_set_info(gc, gc->account->user_info);
 154                 /* g_free(buf); */
 155         }
 156
 157         if (gc->idle_timer > 0)
 158                 g_source_remove(gc->idle_timer);
 159
 160         gc->idle_timer = g_timeout_add(20000, check_idle, gc);
 161         serv_touch_idle(gc);
 162
 163         if (prpl_info->options & OPT_PROTO_CORRECT_TIME)
 164                 serv_add_buddy(gc, gc->username);
 165
 166         update_keepalive(gc, TRUE);
 167 }
 168
 169 /* This should return the elapsed time in seconds in which Gaim will not send
 170  * typing notifications.
 171  * if it returns zero, it will not send any more typing notifications
 172  * typing is a flag - TRUE for typing, FALSE for stopped typing */
 173 int serv_send_typing(struct gaim_connection *g, char *name, int typing) {
 174         GaimPluginProtocolInfo *prpl_info = NULL;
 175
 176         if (g != NULL && g->prpl != NULL)
 177                 prpl_info = GAIM_PLUGIN_PROTOCOL_INFO(g->prpl);
 178
 179         if (g && prpl_info && prpl_info->send_typing)
 180                 return prpl_info->send_typing(g, name, typing);
 181
 182         return 0;
 183 }
 184
 185 struct queued_away_response {
 186         char name[80];
 187         time_t sent_away;
 188 };
 189
 190 struct queued_away_response *find_queued_away_response_by_name(char *name);
 191
 192 int serv_send_im(struct gaim_connection *gc, char *name, char *message,
 193                                  int len, int flags)
 194 {
 195         struct gaim_conversation *c;
 196         int val = -EINVAL;
 197         GaimPluginProtocolInfo *prpl_info = NULL;
 198
 199         if (gc != NULL && gc->prpl != NULL)
 200                 prpl_info = GAIM_PLUGIN_PROTOCOL_INFO(gc->prpl);
 201
 202         c = gaim_find_conversation(name);
 203
 204         if (prpl_info && prpl_info->send_im)
 205                 val = prpl_info->send_im(gc, name, message, len, flags);
 206
 207         if (!(flags & IM_FLAG_AWAY))
 208                 serv_touch_idle(gc);
 209
 210         if (gc->away && away_options & OPT_AWAY_DELAY_IN_USE &&
 211                         !(away_options & OPT_AWAY_NO_AUTO_RESP)) {
 212                 time_t t;
 213                 struct queued_away_response *qar;
 214                 time(&t);
 215                 qar = find_queued_away_response_by_name(name);
 216                 if (!qar) {
 217                         qar = (struct queued_away_response *)g_new0(struct queued_away_response, 1);
 218                         g_snprintf(qar->name, sizeof(qar->name), "%s", name);
 219                         qar->sent_away = 0;
 220                         away_time_queue = g_slist_append(away_time_queue, qar);
 221                 }
 222                 qar->sent_away = t;
 223         }
 224
 225         if (c && gaim_im_get_type_again_timeout(GAIM_IM(c)))
 226                 gaim_im_stop_type_again_timeout(GAIM_IM(c));
 227
 228         return val;
 229 }
 230
 231 void serv_get_info(struct gaim_connection *g, char *name)
 232 {
 233         GaimPluginProtocolInfo *prpl_info = NULL;
 234
 235         if (g != NULL && g->prpl != NULL)
 236                 prpl_info = GAIM_PLUGIN_PROTOCOL_INFO(g->prpl);
 237
 238         if (g && prpl_info && prpl_info->get_info)
 239                 prpl_info->get_info(g, name);
 240 }
 241
 242 void serv_get_away(struct gaim_connection *g, const char *name)
 243 {
 244         GaimPluginProtocolInfo *prpl_info = NULL;
 245
 246         if (g != NULL && g->prpl != NULL)
 247                 prpl_info = GAIM_PLUGIN_PROTOCOL_INFO(g->prpl);
 248
 249         if (g && prpl_info && prpl_info->get_away)
 250                 prpl_info->get_away(g, name);
 251 }
 252
 253 void serv_get_dir(struct gaim_connection *g, char *name)
 254 {
 255         GaimPluginProtocolInfo *prpl_info = NULL;
 256
 257         if (g != NULL && g->prpl != NULL)
 258                 prpl_info = GAIM_PLUGIN_PROTOCOL_INFO(g->prpl);
 259
 260         if (prpl_info && g_slist_find(connections, g) && prpl_info->get_dir)
 261                 prpl_info->get_dir(g, name);
 262 }
 263
 264 void serv_set_dir(struct gaim_connection *g, const char *first,
 265                                   const char *middle, const char *last, const char *maiden,
 266                                   const char *city, const char *state, const char *country,
 267                                   int web)
 268 {
 269         GaimPluginProtocolInfo *prpl_info = NULL;
 270
 271         if (g != NULL && g->prpl != NULL)
 272                 prpl_info = GAIM_PLUGIN_PROTOCOL_INFO(g->prpl);
 273
 274         if (prpl_info && g_slist_find(connections, g) && prpl_info->set_dir)
 275                 prpl_info->set_dir(g, first, middle, last, maiden, city, state,
 276                                                  country, web);
 277 }
 278
 279 void serv_dir_search(struct gaim_connection *g, const char *first,
 280                                          const char *middle, const char *last, const char *maiden,
 281                      const char *city, const char *state, const char *country,
 282                          const char *email)
 283 {
 284         GaimPluginProtocolInfo *prpl_info = NULL;
 285
 286         if (g != NULL && g->prpl != NULL)
 287                 prpl_info = GAIM_PLUGIN_PROTOCOL_INFO(g->prpl);
 288
 289         if (prpl_info && g_slist_find(connections, g) && prpl_info->dir_search)
 290                 prpl_info->dir_search(g, first, middle, last, maiden, city, state,
 291                                                         country, email);
 292 }
 293
 294
 295 void serv_set_away(struct gaim_connection *gc, char *state, char *message)
 296 {
 297         GaimPluginProtocolInfo *prpl_info = NULL;
 298
 299         if (gc->away_state == NULL && state == NULL &&
 300                 gc->away == NULL && message == NULL) {
 301
 302                 return;
 303         }
 304
 305         if ((gc->away_state != NULL && state != NULL &&
 306                  !strcmp(gc->away_state, state) &&
 307                  !strcmp(gc->away_state, GAIM_AWAY_CUSTOM)) &&
 308                 (gc->away != NULL && message != NULL && !strcmp(gc->away, message))) {
 309
 310                 return;
 311         }
 312
 313         if (gc != NULL && gc->prpl != NULL)
 314                 prpl_info = GAIM_PLUGIN_PROTOCOL_INFO(gc->prpl);
 315
 316         if (prpl_info && prpl_info->set_away) {
 317                 char *buf = NULL;
 318
 319                 if (gc->away_state) {
 320                         g_free(gc->away_state);
 321                         gc->away_state = NULL;
 322                 }
 323
 324                 if (message) {
 325                         buf = g_malloc(strlen(message) * 4 + 1);
 326                         if (gc->flags & OPT_CONN_HTML)
 327                                 strncpy_withhtml(buf, message, strlen(message) * 4 + 1);
 328                         else
 329                                 strncpy_nohtml(buf, message, strlen(message) + 1);
 330                 }
 331
 332                 prpl_info->set_away(gc, state, buf);
 333
 334                 if (gc->away && state) {
 335                         gc->away_state = g_strdup(state);
 336                 }
 337
 338                 gaim_event_broadcast(event_away, gc, state, buf);
 339
 340                 if (buf)
 341                         g_free(buf);
 342         }
 343
 344         system_log(log_away, gc, NULL, OPT_LOG_BUDDY_AWAY | OPT_LOG_MY_SIGNON);
 345 }
 346
 347 void serv_set_away_all(char *message)
 348 {
 349         GSList *c;
 350         struct gaim_connection *g;
 351
 352         for (c = connections; c != NULL; c = c->next) {
 353                 g = (struct gaim_connection *)c->data;
 354
 355                 serv_set_away(g, GAIM_AWAY_CUSTOM, message);
 356         }
 357 }
 358
 359 void serv_set_info(struct gaim_connection *g, char *info)
 360 {
 361         GaimPluginProtocolInfo *prpl_info = NULL;
 362
 363         if (g != NULL && g->prpl != NULL)
 364                 prpl_info = GAIM_PLUGIN_PROTOCOL_INFO(g->prpl);
 365
 366         if (prpl_info && g_slist_find(connections, g) && prpl_info->set_info) {
 367                 if (gaim_event_broadcast(event_set_info, g, info))
 368                         return;
 369
 370                 prpl_info->set_info(g, info);
 371         }
 372 }
 373
 374 void serv_change_passwd(struct gaim_connection *g, const char *orig, const char *new)
 375 {
 376         GaimPluginProtocolInfo *prpl_info = NULL;
 377
 378         if (g != NULL && g->prpl != NULL)
 379                 prpl_info = GAIM_PLUGIN_PROTOCOL_INFO(g->prpl);
 380
 381         if (prpl_info && g_slist_find(connections, g) && prpl_info->change_passwd)
 382                 prpl_info->change_passwd(g, orig, new);
 383 }
 384
 385 void serv_add_buddy(struct gaim_connection *g, const char *name)
 386 {
 387         GaimPluginProtocolInfo *prpl_info = NULL;
 388
 389         if (g != NULL && g->prpl != NULL)
 390                 prpl_info = GAIM_PLUGIN_PROTOCOL_INFO(g->prpl);
 391
 392         if (prpl_info && g_slist_find(connections, g) && prpl_info->add_buddy)
 393                 prpl_info->add_buddy(g, name);
 394 }
 395
 396 void serv_add_buddies(struct gaim_connection *g, GList *buddies)
 397 {
 398         GaimPluginProtocolInfo *prpl_info = NULL;
 399
 400         if (g != NULL && g->prpl != NULL)
 401                 prpl_info = GAIM_PLUGIN_PROTOCOL_INFO(g->prpl);
 402
 403         if (prpl_info && g_slist_find(connections, g)) {
 404                 if (prpl_info->add_buddies)
 405                         prpl_info->add_buddies(g, buddies);
 406                 else if (prpl_info->add_buddy) {
 407                         while (buddies) {
 408                                 prpl_info->add_buddy(g, buddies->data);
 409                                 buddies = buddies->next;
 410                         }
 411                 }
 412         }
 413 }
 414
 415
 416 void serv_remove_buddy(struct gaim_connection *g, char *name, char *group)
 417 {
 418         GaimPluginProtocolInfo *prpl_info = NULL;
 419
 420         if (g != NULL && g->prpl != NULL)
 421                 prpl_info = GAIM_PLUGIN_PROTOCOL_INFO(g->prpl);
 422
 423         if (prpl_info && g_slist_find(connections, g) && prpl_info->remove_buddy)
 424                 prpl_info->remove_buddy(g, name, group);
 425 }
 426
 427 void serv_remove_buddies(struct gaim_connection *gc, GList *g, char *group)
 428 {
 429         GaimPluginProtocolInfo *prpl_info = NULL;
 430
 431         if (!g_slist_find(connections, gc))
 432                 return;
 433
 434         if (!gc->prpl)
 435                 return;         /* how the hell did that happen? */
 436
 437         if (gc != NULL && gc->prpl != NULL)
 438                 prpl_info = GAIM_PLUGIN_PROTOCOL_INFO(gc->prpl);
 439
 440         if (prpl_info->remove_buddies)
 441                 prpl_info->remove_buddies(gc, g, group);
 442         else {
 443                 while (g) {
 444                         serv_remove_buddy(gc, g->data, group);
 445                         g = g->next;
 446                 }
 447         }
 448 }
 449
 450 /*
 451  * Set buddy's alias on server roster/list
 452  */
 453 void serv_alias_buddy(struct buddy *b)
 454 {
 455         GaimPluginProtocolInfo *prpl_info = NULL;
 456
 457         if (b != NULL && b->account->gc->prpl != NULL)
 458                 prpl_info = GAIM_PLUGIN_PROTOCOL_INFO(b->account->gc->prpl);
 459
 460         if (b && prpl_info && prpl_info->alias_buddy) {
 461                 prpl_info->alias_buddy(b->account->gc, b->name, b->alias);
 462         }
 463 }
 464
 465 void serv_got_alias(struct gaim_connection *gc, char *who, char *alias) {
 466         struct buddy *b = gaim_find_buddy(gc->account, who);
 467         if(!b)
 468                 return;
 469
 470         if (b->server_alias)
 471                 g_free(b->server_alias);
 472
 473         if(alias)
 474                 b->server_alias = g_strdup(alias);
 475         else
 476                b->server_alias = NULL;
 477
 478         gaim_blist_update_buddy_status(b, b->uc);
 479 }
 480
 481 /*
 482  * Move a buddy from one group to another on server.
 483  *
 484  * Note: For now we'll not deal with changing gc's at the same time, but
 485  * it should be possible.  Probably needs to be done, someday.
 486  */
 487 void serv_move_buddy(struct buddy *b, struct group *og, struct group *ng)
 488 {
 489         GaimPluginProtocolInfo *prpl_info = NULL;
 490
 491         if (b->account->gc != NULL && b->account->gc->prpl != NULL)
 492                 prpl_info = GAIM_PLUGIN_PROTOCOL_INFO(b->account->gc->prpl);
 493
 494         if (b && b->account->gc && og && ng) {
 495                 if (prpl_info && prpl_info->group_buddy) {
 496                         prpl_info->group_buddy(b->account->gc, b->name, og->name, ng->name);
 497                 }
 498         }
 499 }
 500
 501 /*
 502  * Rename a group on server roster/list.
 503  */
 504 void serv_rename_group(struct gaim_connection *g, struct group *old_group,
 505                                            const char *new_name)
 506 {
 507         GaimPluginProtocolInfo *prpl_info = NULL;
 508
 509         if (g != NULL && g->prpl != NULL)
 510                 prpl_info = GAIM_PLUGIN_PROTOCOL_INFO(g->prpl);
 511
 512         if (prpl_info && old_group && new_name) {
 513                 GList *tobemoved = NULL;
 514                 GaimBlistNode *b = ((GaimBlistNode*)old_group)->child;
 515
 516                 while (b) {
 517                         if(GAIM_BLIST_NODE_IS_BUDDY(b)) {
 518                                 struct buddy *bd = (struct buddy *)b;
 519                                 if (bd->account == g->account)
 520                                         tobemoved = g_list_append(tobemoved, bd->name);
 521                         }
 522                         b = b->next;
 523                 }
 524
 525                 if (prpl_info->rename_group) {
 526                         /* prpl's might need to check if the group already
 527                          * exists or not, and handle that differently */
 528                         prpl_info->rename_group(g, old_group->name, new_name, tobemoved);
 529                 } else {
 530                         serv_remove_buddies(g, tobemoved, old_group->name);
 531                         serv_add_buddies(g, tobemoved);
 532                 }
 533
 534                 g_list_free(tobemoved);
 535         }
 536 }
 537
 538 void serv_add_permit(struct gaim_connection *g, const char *name)
 539 {
 540         GaimPluginProtocolInfo *prpl_info = NULL;
 541
 542         if (g != NULL && g->prpl != NULL)
 543                 prpl_info = GAIM_PLUGIN_PROTOCOL_INFO(g->prpl);
 544
 545         if (prpl_info && g_slist_find(connections, g) && prpl_info->add_permit)
 546                 prpl_info->add_permit(g, name);
 547 }
 548
 549 void serv_add_deny(struct gaim_connection *g, const char *name)
 550 {
 551         GaimPluginProtocolInfo *prpl_info = NULL;
 552
 553         if (g != NULL && g->prpl != NULL)
 554                 prpl_info = GAIM_PLUGIN_PROTOCOL_INFO(g->prpl);
 555
 556         if (prpl_info && g_slist_find(connections, g) && prpl_info->add_deny)
 557                 prpl_info->add_deny(g, name);
 558 }
 559
 560 void serv_rem_permit(struct gaim_connection *g, const char *name)
 561 {
 562         GaimPluginProtocolInfo *prpl_info = NULL;
 563
 564         if (g != NULL && g->prpl != NULL)
 565                 prpl_info = GAIM_PLUGIN_PROTOCOL_INFO(g->prpl);
 566
 567         if (prpl_info && g_slist_find(connections, g) && prpl_info->rem_permit)
 568                 prpl_info->rem_permit(g, name);
 569 }
 570
 571 void serv_rem_deny(struct gaim_connection *g, const char *name)
 572 {
 573         GaimPluginProtocolInfo *prpl_info = NULL;
 574
 575         if (g != NULL && g->prpl != NULL)
 576                 prpl_info = GAIM_PLUGIN_PROTOCOL_INFO(g->prpl);
 577
 578         if (prpl_info && g_slist_find(connections, g) && prpl_info->rem_deny)
 579                 prpl_info->rem_deny(g, name);
 580 }
 581
 582 void serv_set_permit_deny(struct gaim_connection *g)
 583 {
 584         GaimPluginProtocolInfo *prpl_info = NULL;
 585
 586         if (g != NULL && g->prpl != NULL)
 587                 prpl_info = GAIM_PLUGIN_PROTOCOL_INFO(g->prpl);
 588
 589         /*
 590          * this is called when either you import a buddy list, and make lots
 591          * of changes that way, or when the user toggles the permit/deny mode
 592          * in the prefs. In either case you should probably be resetting and
 593          * resending the permit/deny info when you get this.
 594          */
 595         if (prpl_info && g_slist_find(connections, g) && prpl_info->set_permit_deny)
 596                 prpl_info->set_permit_deny(g);
 597 }
 598
 599
 600 void serv_set_idle(struct gaim_connection *g, int time)
 601 {
 602         GaimPluginProtocolInfo *prpl_info = NULL;
 603
 604         if (g != NULL && g->prpl != NULL)
 605                 prpl_info = GAIM_PLUGIN_PROTOCOL_INFO(g->prpl);
 606
 607         if (prpl_info && g_slist_find(connections, g) && prpl_info->set_idle)
 608                 prpl_info->set_idle(g, time);
 609 }
 610
 611 void serv_warn(struct gaim_connection *g, char *name, int anon)
 612 {
 613         GaimPluginProtocolInfo *prpl_info = NULL;
 614
 615         if (g != NULL && g->prpl != NULL)
 616                 prpl_info = GAIM_PLUGIN_PROTOCOL_INFO(g->prpl);
 617
 618         if (prpl_info && g_slist_find(connections, g) && prpl_info->warn)
 619                 prpl_info->warn(g, name, anon);
 620 }
 621
 622 void serv_join_chat(struct gaim_connection *g, GHashTable *data)
 623 {
 624         GaimPluginProtocolInfo *prpl_info = NULL;
 625
 626         if (g != NULL && g->prpl != NULL)
 627                 prpl_info = GAIM_PLUGIN_PROTOCOL_INFO(g->prpl);
 628
 629         if (prpl_info && g_slist_find(connections, g) && prpl_info->join_chat)
 630                 prpl_info->join_chat(g, data);
 631 }
 632
 633 void serv_chat_invite(struct gaim_connection *g, int id, const char *message, const char *name)
 634 {
 635         GaimPluginProtocolInfo *prpl_info = NULL;
 636         char *buffy = message && *message ? g_strdup(message) : NULL;
 637
 638         if (g != NULL && g->prpl != NULL)
 639                 prpl_info = GAIM_PLUGIN_PROTOCOL_INFO(g->prpl);
 640
 641         gaim_event_broadcast(event_chat_send_invite, g, (void *)id, name, &buffy);
 642
 643         if (prpl_info && g_slist_find(connections, g) && prpl_info->chat_invite)
 644                 prpl_info->chat_invite(g, id, buffy, name);
 645
 646         if (buffy)
 647                 g_free(buffy);
 648 }
 649
 650 void serv_chat_leave(struct gaim_connection *g, int id)
 651 {
 652         GaimPluginProtocolInfo *prpl_info = NULL;
 653
 654         if (!g_slist_find(connections, g))
 655                 return;
 656
 657         if (g->prpl != NULL)
 658                 prpl_info = GAIM_PLUGIN_PROTOCOL_INFO(g->prpl);
 659
 660         if (prpl_info && prpl_info->chat_leave)
 661                 prpl_info->chat_leave(g, id);
 662 }
 663
 664 void serv_chat_whisper(struct gaim_connection *g, int id, char *who, char *message)
 665 {
 666         GaimPluginProtocolInfo *prpl_info = NULL;
 667
 668         if (g != NULL && g->prpl != NULL)
 669                 prpl_info = GAIM_PLUGIN_PROTOCOL_INFO(g->prpl);
 670
 671         if (prpl_info && prpl_info->chat_whisper)
 672                 prpl_info->chat_whisper(g, id, who, message);
 673 }
 674
 675 int serv_chat_send(struct gaim_connection *g, int id, char *message)
 676 {
 677         int val = -EINVAL;
 678         GaimPluginProtocolInfo *prpl_info = NULL;
 679
 680         if (g->prpl != NULL)
 681                 prpl_info = GAIM_PLUGIN_PROTOCOL_INFO(g->prpl);
 682
 683         if (prpl_info && prpl_info->chat_send)
 684                 val = prpl_info->chat_send(g, id, message);
 685
 686         serv_touch_idle(g);
 687
 688         return val;
 689 }
 690
 691 int find_queue_row_by_name(char *name)
 692 {
 693         gchar *temp;
 694         gint i = 0;
 695         gboolean valid;
 696         GtkTreeIter iter;
 697
 698         valid = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(awayqueuestore), &iter);
 699         while(valid) {
 700                 gtk_tree_model_get(GTK_TREE_MODEL(awayqueuestore), &iter, 0, &temp, -1);
 701                 if(!strcmp(name, temp))
 702                         return i;
 703                 g_free(temp);
 704
 705                 i++;
 706                 valid = gtk_tree_model_iter_next(GTK_TREE_MODEL(awayqueuestore), &iter);
 707         }
 708
 709         return -1;
 710 }
 711
 712 int find_queue_total_by_name(char *name)
 713 {
 714         GSList *templist;
 715         int i = 0;
 716
 717         templist = message_queue;
 718
 719         while (templist) {
 720                 struct queued_message *qm = (struct queued_message *)templist->data;
 721                 if ((qm->flags & WFLAG_RECV) && !strcmp(name, qm->name))
 722                         i++;
 723
 724                 templist = templist->next;
 725         }
 726
 727         return i;
 728 }
 729
 730 struct queued_away_response *find_queued_away_response_by_name(char *name)
 731 {
 732         GSList *templist;
 733         struct queued_away_response *qar;
 734
 735         templist = away_time_queue;
 736
 737         while (templist) {
 738                 qar = (struct queued_away_response *)templist->data;
 739
 740                 if (!strcmp(name, qar->name))
 741                         return qar;
 742
 743                 templist = templist->next;
 744         }
 745
 746         return NULL;
 747 }
 748
 749 /*
 750  * woo. i'm actually going to comment this function. isn't that fun. make
 751  * sure to follow along, kids
 752  */
 753 void serv_got_im(struct gaim_connection *gc, const char *who, const char *msg,
 754                                  guint32 flags, time_t mtime, gint len)
 755 {
 756         char *buffy;
 757         char *angel;
 758         int plugin_return;
 759         int away = 0;
 760
 761         struct gaim_conversation *cnv;
 762
 763         char *message, *name;
 764
 765         /*
 766          * Pay no attention to the man behind the curtain.
 767          *
 768          * The reason i feel okay with this is because it's useful to some
 769          * plugins. Gaim doesn't ever use it itself. Besides, it's not entirely
 770          * accurate; it's possible to have false negatives with most protocols.
 771          * Also with some it's easy to have false positives as well. So if you're
 772          * a plugin author, don't rely on this, still do your own checks. But uh.
 773          * It's a start.
 774          */
 775
 776         if (flags & IM_FLAG_GAIMUSER)
 777                 gaim_debug(GAIM_DEBUG_MISC, "server", "%s is a gaim user.\n", who);
 778
 779         /*
 780          * We should update the conversation window buttons and menu,
 781          * if it exists.
 782          */
 783         cnv = gaim_find_conversation_with_account(who, gc->account);
 784
 785         /*
 786          * Plugin stuff. we pass a char ** but we don't want to pass what's
 787          * been given us by the prpls. So we create temp holders and pass
 788          * those instead. It's basically just to avoid segfaults. Of course,
 789          * if the data is binary, plugins don't see it. Bitch all you want;
 790          * I really don't want you to be dealing with it.
 791          */
 792         if (len < 0) {
 793                 buffy = g_malloc(MAX(strlen(msg) + 1, BUF_LONG));
 794                 strcpy(buffy, msg);
 795                 angel = g_strdup(who);
 796                 plugin_return = gaim_event_broadcast(event_im_recv, gc, &angel, &buffy, &flags);
 797
 798                 if (!buffy || !angel || plugin_return) {
 799                         if (buffy)
 800                                 g_free(buffy);
 801                         if (angel)
 802                                 g_free(angel);
 803                         return;
 804                 }
 805                 name = angel;
 806                 message = buffy;
 807         } else {
 808                 name = g_strdup(who);
 809                 message = g_memdup(msg, len);
 810         }
 811
 812         /*
 813          * If you can't figure this out, stop reading right now.
 814          * "We're not worthy! We're not worthy!"
 815          */
 816         if ((len < 0) && (convo_options & OPT_CONVO_SEND_LINKS)) {
 817                 buffy = linkify_text(message);
 818                 g_free(message);
 819                 message = buffy;
 820         }
 821
 822         /*
 823          * Um. When we call gaim_conversation_write with the message we received,
 824          * it's nice to pass whether or not it was an auto-response. So if it
 825          * was an auto-response, we set the appropriate flag. This is just so
 826          * prpls don't have to know about WFLAG_* (though some do anyway)
 827          */
 828         if (flags & IM_FLAG_AWAY)
 829                 away = WFLAG_AUTO;
 830
 831         /*
 832          * Alright. Two cases for how to handle this. Either we're away or
 833          * we're not. If we're not, then it's easy. If we are, then there
 834          * are three or four different ways of handling it and different
 835          * things we have to do for each.
 836          */
 837         if (gc->away) {
 838                 time_t t;
 839                 char *tmpmsg;
 840                 struct buddy *b = gaim_find_buddy(gc->account, name);
 841                 char *alias = b ? gaim_get_buddy_alias(b) : name;
 842                 int row;
 843                 struct queued_away_response *qar;
 844
 845                 time(&t);
 846
 847                 /*
 848                  * Either we're going to queue it or not. Because of the way
 849                  * awayness currently works, this is fucked up. It's possible
 850                  * for an account to be away without the imaway dialog being
 851                  * shown. In fact, it's possible for *all* the accounts to be
 852                  * away without the imaway dialog being shown. So in order for
 853                  * this to be queued properly, we have to make sure that the
 854                  * imaway dialog actually exists, first.
 855                  */
 856                 if (!cnv && awayqueue && (away_options & OPT_AWAY_QUEUE)) {
 857                         /*
 858                          * Alright, so we're going to queue it. Neat, eh? :)
 859                          * So first we create something to store the message, and add
 860                          * it to our queue. Then we update the away dialog to indicate
 861                          * that we've queued something.
 862                          */
 863                         struct queued_message *qm;
 864                         GtkTreeIter iter;
 865                         gchar path[10];
 866
 867                         qm = g_new0(struct queued_message, 1);
 868                         g_snprintf(qm->name, sizeof(qm->name), "%s", name);
 869                         qm->message = g_memdup(message, len == -1 ? strlen(message) + 1 : len);
 870                         qm->account = gc->account;
 871                         qm->tm = mtime;
 872                         qm->flags = WFLAG_RECV | away;
 873                         qm->len = len;
 874                         message_queue = g_slist_append(message_queue, qm);
 875
 876                         row = find_queue_row_by_name(qm->name);
 877                         if (row >= 0) {
 878                                 char number[32];
 879                                 int qtotal;
 880
 881                                 qtotal = find_queue_total_by_name(qm->name);
 882                                 g_snprintf(number, 32, _("(%d messages)"), qtotal);
 883                                 g_snprintf(path, 10, "%d", row);
 884                                 gtk_tree_model_get_iter_from_string(
 885                                                                 GTK_TREE_MODEL(awayqueuestore), &iter, path);
 886                                 gtk_list_store_set(awayqueuestore, &iter,
 887                                                                 1, number, -1);
 888                         } else {
 889                                 gtk_tree_model_get_iter_first(GTK_TREE_MODEL(awayqueuestore),
 890                                                                 &iter);
 891                                 gtk_list_store_append(awayqueuestore, &iter);
 892                                 gtk_list_store_set(awayqueuestore, &iter,
 893                                                                 0, qm->name,
 894                                                                 1, _("(1 message)"),
 895                                                                 -1);
 896                         }
 897                 } else {
 898                         /*
 899                          * Make sure the conversation
 900                          * exists and is updated (partly handled above already), play
 901                          * the receive sound (sound.c will take care of not playing
 902                          * while away), and then write it to the convo window.
 903                          */
 904                         if (cnv == NULL)
 905                                 cnv = gaim_conversation_new(GAIM_CONV_IM, gc->account, name);
 906
 907                         gaim_im_write(GAIM_IM(cnv), NULL, message, len,
 908                                                   away | WFLAG_RECV, mtime);
 909                 }
 910
 911                 /*
 912                  * Regardless of whether we queue it or not, we should send an
 913                  * auto-response. That is, of course, unless the horse.... no wait.
 914                  * Don't autorespond if:
 915                  *
 916                  *  - it's not supported on this connection
 917                  *  - or it's disabled
 918                  *  - or the away message is empty
 919                  *  - or we're not idle and the 'only auto respond if idle' pref
 920                  *    is set
 921                  */
 922                 if (!(gc->flags & OPT_CONN_AUTO_RESP) ||
 923                         (away_options & OPT_AWAY_NO_AUTO_RESP) || !strlen(gc->away) ||
 924                         ((away_options & OPT_AWAY_IDLE_RESP) && !gc->is_idle)) {
 925
 926                         g_free(name);
 927                         g_free(message);
 928                         return;
 929                 }
 930
 931                 /*
 932                  * This used to be based on the conversation window. But um, if
 933                  * you went away, and someone sent you a message and got your
 934                  * auto-response, and then you closed the window, and then the
 935                  * sent you another one, they'd get the auto-response back too
 936                  * soon. Besides that, we need to keep track of this even if we've
 937                  * got a queue. So the rest of this block is just the auto-response,
 938                  * if necessary
 939                  */
 940                 qar = find_queued_away_response_by_name(name);
 941                 if (!qar) {
 942                         qar = (struct queued_away_response *)g_new0(struct queued_away_response, 1);
 943                         g_snprintf(qar->name, sizeof(qar->name), "%s", name);
 944                         qar->sent_away = 0;
 945                         away_time_queue = g_slist_append(away_time_queue, qar);
 946                 }
 947                 if ((t - qar->sent_away) < away_resend) {
 948                         g_free(name);
 949                         g_free(message);
 950                         return;
 951                 }
 952                 qar->sent_away = t;
 953
 954                 /* apply default fonts and colors */
 955                 tmpmsg = stylize(gc->away, MSG_LEN);
 956                 serv_send_im(gc, name, away_subs(tmpmsg, alias), -1, IM_FLAG_AWAY);
 957                 if (!cnv && awayqueue && (away_options & OPT_AWAY_QUEUE)) {
 958                         struct queued_message *qm;
 959                         qm = g_new0(struct queued_message, 1);
 960                         g_snprintf(qm->name, sizeof(qm->name), "%s", name);
 961                         qm->message = g_strdup(away_subs(tmpmsg, alias));
 962                         qm->account = gc->account;
 963                         qm->tm = mtime;
 964                         qm->flags = WFLAG_SEND | WFLAG_AUTO;
 965                         qm->len = -1;
 966                         message_queue = g_slist_append(message_queue, qm);
 967                 } else if (cnv != NULL)
 968                         gaim_im_write(GAIM_IM(cnv), NULL, away_subs(tmpmsg, alias),
 969                                                   len, WFLAG_SEND | WFLAG_AUTO, mtime);
 970
 971                 g_free(tmpmsg);
 972         } else {
 973                 /*
 974                  * We're not away. This is easy. If the convo window doesn't
 975                  * exist, create and update it (if it does exist it was updated
 976                  * earlier), then play a sound indicating we've received it and
 977                  * then display it. Easy.
 978                  */
 979                 if (away_options & OPT_AWAY_QUEUE_UNREAD &&
 980                         !gaim_find_conversation(name) && docklet_count) {
 981
 982                         /*
 983                          * We're gonna queue it up and wait for the user to ask for
 984                          * it... probably by clicking the docklet or windows tray icon.
 985                          */
 986                         struct queued_message *qm;
 987                         qm = g_new0(struct queued_message, 1);
 988                         g_snprintf(qm->name, sizeof(qm->name), "%s", name);
 989                         qm->message = g_strdup(message);
 990                         qm->account = gc->account;
 991                         qm->tm = mtime;
 992                         qm->flags = away | WFLAG_RECV;
 993                         qm->len = len;
 994                         unread_message_queue = g_slist_append(unread_message_queue, qm);
 995                 } else {
 996                         if (cnv == NULL)
 997                                 cnv = gaim_conversation_new(GAIM_CONV_IM, gc->account, name);
 998
 999                         /* CONV XXX gaim_conversation_set_name(cnv, name); */
1000
1001                         gaim_im_write(GAIM_IM(cnv), NULL, message, len,
1002                                                   away | WFLAG_RECV, mtime);
1003                         gaim_window_flash(gaim_conversation_get_window(cnv));
1004                 }
1005         }
1006
1007         gaim_event_broadcast(event_im_displayed_rcvd, gc, name, message, flags, mtime);
1008         g_free(name);
1009         g_free(message);
1010 }
1011
1012
1013
1014 void serv_got_update(struct gaim_connection *gc, char *name, int loggedin,
1015                                          int evil, time_t signon, time_t idle, int type)
1016 {
1017         struct buddy *b = gaim_find_buddy(gc->account, name);
1018
1019         if (signon && (GAIM_PLUGIN_PROTOCOL_INFO(gc->prpl)->options &
1020                                    OPT_PROTO_CORRECT_TIME)) {
1021
1022                 char *tmp = g_strdup(normalize(name));
1023                 if (!gaim_utf8_strcasecmp(tmp, normalize(gc->username))) {
1024                         gc->evil = evil;
1025                         gc->login_time_official = signon;
1026                         /*update_idle_times();*/
1027                 }
1028                 g_free(tmp);
1029         }
1030
1031         if (!b) {
1032                 gaim_debug(GAIM_DEBUG_ERROR, "server",
1033                                    "No such buddy: %s\n", name);
1034                 return;
1035         }
1036
1037         /* This code will 'align' the name from the TOC */
1038         /* server with what's in our record.  We want to */
1039         /* store things how THEY want it... */
1040         if (strcmp(name, b->name)) {
1041                 gaim_blist_rename_buddy(b, name);
1042                 gaim_blist_save();
1043         }
1044
1045         if (!b->idle && idle) {
1046                 gaim_pounce_execute(gc->account, b->name, GAIM_POUNCE_IDLE);
1047                 gaim_event_broadcast(event_buddy_idle, gc, b->name);
1048                 system_log(log_idle, gc, b, OPT_LOG_BUDDY_IDLE);
1049         }
1050         if (b->idle && !idle) {
1051                 gaim_pounce_execute(gc->account, b->name, GAIM_POUNCE_IDLE_RETURN);
1052                 gaim_event_broadcast(event_buddy_unidle, gc, b->name);
1053                 system_log(log_unidle, gc, b, OPT_LOG_BUDDY_IDLE);
1054         }
1055
1056         gaim_blist_update_buddy_idle(b, idle);
1057         gaim_blist_update_buddy_evil(b, evil);
1058
1059         if ((b->uc & UC_UNAVAILABLE) && !(type & UC_UNAVAILABLE)) {
1060                 gaim_pounce_execute(gc->account, b->name, GAIM_POUNCE_AWAY_RETURN);
1061                 system_log(log_back, gc, b, OPT_LOG_BUDDY_AWAY);
1062         } else if (!(b->uc & UC_UNAVAILABLE) && (type & UC_UNAVAILABLE)) {
1063                 gaim_pounce_execute(gc->account, b->name, GAIM_POUNCE_AWAY);
1064                 system_log(log_away, gc, b, OPT_LOG_BUDDY_AWAY);
1065         }
1066
1067         gaim_blist_update_buddy_status(b, type);
1068
1069
1070         if (loggedin) {
1071                 if (!GAIM_BUDDY_IS_ONLINE(b)) {
1072                         struct gaim_conversation *c = gaim_find_conversation(b->name);
1073                         if (c && (im_options & OPT_IM_LOGON)) {
1074                                 char *tmp = g_strdup_printf(_("%s logged in."), gaim_get_buddy_alias(b));
1075                                 gaim_conversation_write(c, NULL, tmp, -1,
1076                                                         WFLAG_SYSTEM, time(NULL));
1077                                 g_free(tmp);
1078                         } else if (awayqueue && find_queue_total_by_name(b->name)) {
1079                                 struct queued_message *qm = g_new0(struct queued_message, 1);
1080                                 g_snprintf(qm->name, sizeof(qm->name), "%s", b->name);
1081                                 qm->message = g_strdup_printf(_("%s logged in."),
1082                                                               gaim_get_buddy_alias(b));
1083                                 qm->account = gc->account;
1084                                 qm->tm = time(NULL);
1085                                 qm->flags = WFLAG_SYSTEM;
1086                                 qm->len = -1;
1087                                 message_queue = g_slist_append(message_queue, qm);
1088                         }
1089                         gaim_sound_play_event(GAIM_SOUND_BUDDY_ARRIVE);
1090                         gaim_pounce_execute(gc->account, b->name, GAIM_POUNCE_SIGNON);
1091                         system_log(log_signon, gc, b, OPT_LOG_BUDDY_SIGNON);
1092                 }
1093         } else {
1094                 if (GAIM_BUDDY_IS_ONLINE(b)) {
1095                         struct gaim_conversation *c = gaim_find_conversation(b->name);
1096                         if (c && (im_options & OPT_IM_LOGON)) {
1097                                 char *tmp = g_strdup_printf(_("%s logged out."), gaim_get_buddy_alias(b));
1098                                 gaim_conversation_write(c, NULL, tmp, -1,
1099                                                         WFLAG_SYSTEM, time(NULL));
1100                                 g_free(tmp);
1101                         } else if (awayqueue && find_queue_total_by_name(b->name)) {
1102                                 struct queued_message *qm = g_new0(struct queued_message, 1);
1103                                 g_snprintf(qm->name, sizeof(qm->name), "%s", b->name);
1104                                 qm->message = g_strdup_printf(_("%s logged out."),
1105                                                               gaim_get_buddy_alias(b));
1106                                 qm->account = gc->account;
1107                                 qm->tm = time(NULL);
1108                                 qm->flags = WFLAG_SYSTEM;
1109                                 qm->len = -1;
1110                                 message_queue = g_slist_append(message_queue, qm);
1111                         }
1112                         serv_got_typing_stopped(gc, name); /* obviously not typing */
1113                         gaim_sound_play_event(GAIM_SOUND_BUDDY_LEAVE);
1114                         gaim_pounce_execute(gc->account, b->name, GAIM_POUNCE_SIGNOFF);
1115                         system_log(log_signoff, gc, b, OPT_LOG_BUDDY_SIGNON);
1116                 }
1117         }
1118
1119         gaim_blist_update_buddy_presence(b, loggedin);
1120
1121 }
1122
1123
1124 void serv_got_eviled(struct gaim_connection *gc, char *name, int lev)
1125 {
1126         char buf2[1024];
1127
1128         gaim_event_broadcast(event_warned, gc, name, lev);
1129
1130         if (gc->evil >= lev) {
1131                 gc->evil = lev;
1132                 return;
1133         }
1134
1135         gc->evil = lev;
1136
1137         g_snprintf(buf2, sizeof(buf2),
1138                            _("%s has just been warned by %s.\n"
1139                                  "Your new warning level is %d%%"),
1140                            gc->username,
1141                            ((name == NULL)? _("an anonymous person") : name), lev);
1142
1143         gaim_notify_info(NULL, NULL, buf2, NULL);
1144 }
1145
1146 void serv_got_typing(struct gaim_connection *gc, char *name, int timeout,
1147                                          int state) {
1148
1149         struct buddy *b;
1150         struct gaim_conversation *cnv = gaim_find_conversation(name);
1151         struct gaim_im *im;
1152
1153         if (!cnv)
1154                 return;
1155
1156         im = GAIM_IM(cnv);
1157
1158         gaim_conversation_set_account(cnv, gc->account);
1159         gaim_im_set_typing_state(im, state);
1160         gaim_im_update_typing(im);
1161
1162         b = gaim_find_buddy(gc->account, name);
1163
1164         gaim_event_broadcast(event_got_typing, gc, name);
1165
1166         if (b != NULL)
1167                 gaim_pounce_execute(gc->account, name, GAIM_POUNCE_TYPING);
1168
1169         if (timeout > 0)
1170                 gaim_im_start_typing_timeout(im, timeout);
1171 }
1172
1173 void serv_got_typing_stopped(struct gaim_connection *gc, char *name) {
1174
1175         struct gaim_conversation *c = gaim_find_conversation(name);
1176         struct gaim_im *im;
1177         struct buddy *b;
1178
1179         if (!c)
1180                 return;
1181
1182         im = GAIM_IM(c);
1183
1184         if (im->typing_state == NOT_TYPING)
1185                 return;
1186
1187         gaim_im_stop_typing_timeout(im);
1188         gaim_im_set_typing_state(im, NOT_TYPING);
1189         gaim_im_update_typing(im);
1190
1191         b = gaim_find_buddy(gc->account, name);
1192
1193         if (b != NULL)
1194                 gaim_pounce_execute(gc->account, name, GAIM_POUNCE_TYPING_STOPPED);
1195 }
1196
1197 struct chat_invite_data {
1198         struct gaim_connection *gc;
1199         GHashTable *components;
1200 };
1201
1202 static void chat_invite_data_free(struct chat_invite_data *cid)
1203 {
1204         if (cid->components)
1205                 g_hash_table_destroy(cid->components);
1206         g_free(cid);
1207 }
1208
1209 static void chat_invite_accept(struct chat_invite_data *cid)
1210 {
1211         serv_join_chat(cid->gc, cid->components);
1212
1213         chat_invite_data_free(cid);
1214 }
1215
1216
1217
1218 void serv_got_chat_invite(struct gaim_connection *gc, char *name,
1219                                                   char *who, char *message, GHashTable *data)
1220 {
1221         char buf2[BUF_LONG];
1222         struct chat_invite_data *cid = g_new0(struct chat_invite_data, 1);
1223
1224
1225         gaim_event_broadcast(event_chat_invited, gc, who, name, message);
1226
1227         if (message)
1228                 g_snprintf(buf2, sizeof(buf2),
1229                                    _("User '%s' invites %s to buddy chat room: '%s'\n%s"),
1230                                    who, gc->username, name, message);
1231         else
1232                 g_snprintf(buf2, sizeof(buf2),
1233                                    _("User '%s' invites %s to buddy chat room: '%s'\n"),
1234                                    who, gc->username, name);
1235
1236         cid->gc = gc;
1237         cid->components = data;
1238
1239         do_ask_dialog(_("Buddy Chat Invite"), buf2, cid, _("Accept"), chat_invite_accept, _("Cancel"), chat_invite_data_free, NULL, FALSE);
1240 }
1241
1242 struct gaim_conversation *serv_got_joined_chat(struct gaim_connection *gc,
1243                                                                                            int id, char *name)
1244 {
1245         struct gaim_conversation *b;
1246         struct gaim_chat *chat;
1247
1248         b = gaim_conversation_new(GAIM_CONV_CHAT, gc->account, name);
1249         chat = GAIM_CHAT(b);
1250
1251         gc->buddy_chats = g_slist_append(gc->buddy_chats, b);
1252
1253         gaim_chat_set_id(chat, id);
1254
1255         if ((logging_options & OPT_LOG_CHATS) ||
1256                 find_log_info(gaim_conversation_get_name(b))) {
1257
1258                 FILE *fd;
1259                 char *filename;
1260
1261                 filename = (char *)malloc(100);
1262                 g_snprintf(filename, 100, "%s.chat", gaim_conversation_get_name(b));
1263
1264                 fd = open_log_file(filename, TRUE);
1265
1266                 if (fd) {
1267                         if (!(logging_options & OPT_LOG_STRIP_HTML))
1268                                 fprintf(fd,
1269                                         "<HR><BR><H3 Align=Center> ---- New Conversation @ %s ----</H3><BR>\n",
1270                                         full_date());
1271                         else
1272                                 fprintf(fd, "---- New Conversation @ %s ----\n", full_date());
1273
1274                         fclose(fd);
1275                 }
1276                 free(filename);
1277         }
1278
1279         gaim_window_show(gaim_conversation_get_window(b));
1280         gaim_window_switch_conversation(gaim_conversation_get_window(b),
1281                                                                         gaim_conversation_get_index(b));
1282
1283         gaim_event_broadcast(event_chat_join, gc, id, name);
1284
1285         return b;
1286 }
1287
1288 void serv_got_chat_left(struct gaim_connection *g, int id)
1289 {
1290         GSList *bcs;
1291         struct gaim_conversation *conv = NULL;
1292         struct gaim_chat *chat = NULL;
1293
1294         for (bcs = g->buddy_chats; bcs != NULL; bcs = bcs->next) {
1295                 conv = (struct gaim_conversation *)bcs->data;
1296
1297                 chat = GAIM_CHAT(conv);
1298
1299                 if (gaim_chat_get_id(chat) == id)
1300                         break;
1301
1302                 conv = NULL;
1303         }
1304
1305         if (!conv)
1306                 return;
1307
1308         gaim_event_broadcast(event_chat_leave, g, gaim_chat_get_id(chat));
1309
1310         gaim_debug(GAIM_DEBUG_INFO, "server", "Leaving room: %s\n",
1311                            gaim_conversation_get_name(conv));
1312
1313         g->buddy_chats = g_slist_remove(g->buddy_chats, conv);
1314
1315         gaim_conversation_destroy(conv);
1316 }
1317
1318 void serv_got_chat_in(struct gaim_connection *g, int id, char *who,
1319                                           int whisper, char *message, time_t mtime)
1320 {
1321         int w;
1322         GSList *bcs;
1323         struct gaim_conversation *conv = NULL;
1324         struct gaim_chat *chat = NULL;
1325         char *buf;
1326         char *buffy, *angel;
1327         int plugin_return;
1328
1329         for (bcs = g->buddy_chats; bcs != NULL; bcs = bcs->next) {
1330                 conv = (struct gaim_conversation *)bcs->data;
1331
1332                 chat = GAIM_CHAT(conv);
1333
1334                 if (gaim_chat_get_id(chat) == id)
1335                         break;
1336
1337                 conv = NULL;
1338         }
1339
1340         if (!conv)
1341                 return;
1342
1343         /*
1344          * Plugin stuff. We pass a char ** but we don't want to pass what's
1345          * been given us by the prpls. so we create temp holders and pass those
1346          * instead. It's basically just to avoid segfaults. Of course, if the
1347          * data is binary, plugins don't see it. Bitch all you want; i really
1348          * don't want you to be dealing with it.
1349          */
1350
1351         buffy = g_malloc(MAX(strlen(message) + 1, BUF_LONG));
1352         strcpy(buffy, message);
1353         angel = g_strdup(who);
1354         plugin_return = gaim_event_broadcast(event_chat_recv, g, gaim_chat_get_id(chat),
1355                                                                  &angel, &buffy);
1356
1357         if (!buffy || !angel || plugin_return) {
1358                 if (buffy)
1359                         g_free(buffy);
1360                 if (angel)
1361                         g_free(angel);
1362                 return;
1363         }
1364         who = angel;
1365         message = buffy;
1366
1367
1368
1369         if (convo_options & OPT_CONVO_SEND_LINKS)
1370                 buf = linkify_text(message);
1371         else
1372                 buf = g_strdup(message);
1373
1374         if (whisper)
1375                 w = WFLAG_WHISPER;
1376         else
1377                 w = 0;
1378
1379         gaim_chat_write(chat, who, buf, w, mtime);
1380
1381         g_free(who);
1382         g_free(message);
1383         g_free(buf);
1384 }
1385
1386 static void des_popup(GtkWidget *w, GtkWidget *window)
1387 {
1388         if (w == window) {
1389                 char *u = g_object_get_data(G_OBJECT(window), "url");
1390                 g_free(u);
1391         }
1392         gtk_widget_destroy(window);
1393 }
1394
1395 void serv_got_popup(char *msg, char *u, int wid, int hei)
1396 {
1397         GtkWidget *window;
1398         GtkWidget *vbox;
1399         GtkWidget *sw;
1400         GtkWidget *text;
1401         GtkWidget *hbox;
1402         GtkWidget *button;
1403         char *url = g_strdup(u);
1404
1405         GAIM_DIALOG(window);
1406         gtk_window_set_role(GTK_WINDOW(window), "popup");
1407         gtk_window_set_resizable(GTK_WINDOW(window), FALSE);
1408         gtk_window_set_title(GTK_WINDOW(window), _("Gaim - Popup"));
1409         gtk_container_set_border_width(GTK_CONTAINER(window), 5);
1410         g_signal_connect(G_OBJECT(window), "destroy",
1411                                          G_CALLBACK(des_popup), window);
1412         g_object_set_data(G_OBJECT(window), "url", url);
1413         gtk_widget_realize(window);
1414
1415         vbox = gtk_vbox_new(FALSE, 5);
1416         gtk_container_add(GTK_CONTAINER(window), vbox);
1417
1418         sw = gtk_scrolled_window_new(NULL, NULL);
1419         gtk_widget_set_size_request(sw, wid, hei);
1420         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
1421         gtk_box_pack_start(GTK_BOX(vbox), sw, TRUE, TRUE, 5);
1422
1423         text = gtk_imhtml_new(NULL, NULL);
1424         gtk_container_add(GTK_CONTAINER(sw), text);
1425         gaim_setup_imhtml(text);
1426
1427         hbox = gtk_hbox_new(FALSE, 5);
1428         gtk_box_pack_end(GTK_BOX(vbox), hbox, FALSE, FALSE, 5);
1429
1430         button = gaim_pixbuf_button_from_stock(_("Close"), GTK_STOCK_CLOSE, GAIM_BUTTON_HORIZONTAL);
1431         gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, FALSE, 5);
1432         g_signal_connect(G_OBJECT(button), "clicked",
1433                                          G_CALLBACK(des_popup), window);
1434
1435         button = gaim_pixbuf_button_from_stock(_("More Info"), GTK_STOCK_FIND, GAIM_BUTTON_HORIZONTAL);
1436         gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, FALSE, 5);
1437         g_signal_connect(G_OBJECT(button), "clicked",
1438                                          G_CALLBACK(open_url), url);
1439
1440         gtk_widget_show_all(window);
1441
1442         gtk_imhtml_append_text(GTK_IMHTML(text), msg, -1, GTK_IMHTML_NO_NEWLINE);
1443 }