src/protocols/napster/napster.c

   1 /*
   2  * gaim - Napster Protocol Plugin
   3  *
   4  * Copyright (C) 2000-2001, Rob Flynn <rob@tgflinux.com>
   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 #include <config.h>
  23
  24 #include <netdb.h>
  25 #include <unistd.h>
  26 #include <errno.h>
  27 #include <netinet/in.h>
  28 #include <arpa/inet.h>
  29 #include <time.h>
  30 #include <string.h>
  31 #include <stdlib.h>
  32 #include <stdio.h>
  33 #include <time.h>
  34 #include <sys/socket.h>
  35 #include <sys/stat.h>
  36 #include "multi.h"
  37 #include "prpl.h"
  38 #include "gaim.h"
  39 #include "proxy.h"
  40 #include "pixmaps/napster.xpm"
  41
  42 #define NAP_BUF_LEN 4096
  43
  44 GSList *nap_connections = NULL;
  45
  46 static unsigned int chat_id = 0;
  47
  48 struct nap_channel {
  49         unsigned int id;
  50         gchar *name;
  51 };
  52
  53 struct nap_data {
  54         int fd;
  55         int inpa;
  56
  57         gchar *email;
  58         GSList *channels;
  59 };
  60
  61 static char *nap_name()
  62 {
  63         return "Napster";
  64 }
  65
  66
  67 /* FIXME: Make this use va_arg stuff */
  68 static void nap_write_packet(struct gaim_connection *gc, unsigned short command, char *message)
  69 {
  70         struct nap_data *ndata = (struct nap_data *)gc->proto_data;
  71         unsigned short size;
  72
  73         size = strlen(message);
  74
  75         write(ndata->fd, &size, 2);
  76         write(ndata->fd, &command, 2);
  77         write(ndata->fd, message, size);
  78 }
  79
  80 static int nap_send_im(struct gaim_connection *gc, char *who, char *message, int len, int flags)
  81 {
  82         gchar buf[NAP_BUF_LEN];
  83
  84         g_snprintf(buf, NAP_BUF_LEN, "%s %s", who, message);
  85         nap_write_packet(gc, 0xCD, buf);
  86
  87         return 1;
  88 }
  89
  90 static struct nap_channel *find_channel_by_name(struct gaim_connection *gc, char *name)
  91 {
  92         struct nap_channel *channel;
  93         struct nap_data *ndata = (struct nap_data *)gc->proto_data;
  94         GSList *channels;
  95
  96         channels = ndata->channels;
  97
  98         while (channels) {
  99                 channel = (struct nap_channel *)channels->data;
 100
 101                 if (channel) {
 102                         if (!g_strcasecmp(name, channel->name)) {
 103                                 return channel;
 104                         }
 105                 }
 106                 channels = g_slist_next(channels);
 107         }
 108
 109         return NULL;
 110 }
 111
 112 static struct nap_channel *find_channel_by_id(struct gaim_connection *gc, int id)
 113 {
 114         struct nap_channel *channel;
 115         struct nap_data *ndata = (struct nap_data *)gc->proto_data;
 116         GSList *channels;
 117
 118         channels = ndata->channels;
 119
 120         while (channels) {
 121                 channel = (struct nap_channel *)channels->data;
 122                 if (id == channel->id) {
 123                         return channel;
 124                 }
 125
 126                 channels = g_slist_next(channels);
 127         }
 128
 129         return NULL;
 130 }
 131
 132 static struct conversation *find_conversation_by_id(struct gaim_connection *gc, int id)
 133 {
 134         GSList *bc = gc->buddy_chats;
 135         struct conversation *b = NULL;
 136
 137         while (bc) {
 138                 b = (struct conversation *)bc->data;
 139                 if (id == b->id) {
 140                         break;
 141                 }
 142                 bc = bc->next;
 143                 b = NULL;
 144         }
 145
 146         return b;
 147 }
 148
 149 static void nap_callback(gpointer data, gint source, GaimInputCondition condition)
 150 {
 151         struct gaim_connection *gc = data;
 152         struct nap_data *ndata = gc->proto_data;
 153         gchar *buf;
 154         unsigned short header[2];
 155         int len;
 156         int command;
 157         gchar **res;
 158         int i;
 159
 160         if (recv(source, header, 4, 0) != 4) {
 161                 hide_login_progress(gc, "Unable to read");
 162                 signoff(gc);
 163                 return;
 164         }
 165
 166         len = header[0];
 167         command = header[1];
 168
 169         buf = (gchar *)g_malloc(sizeof(gchar) * (len + 1));
 170
 171         i = 0;
 172         do {
 173                 int tmp = recv(source, buf + i, len - i, 0);
 174                 if (tmp <= 0) {
 175                         g_free(buf);
 176                         hide_login_progress(gc, "Unable to read");
 177                         signoff(gc);
 178                         return;
 179                 }
 180                 i += tmp;
 181         } while (i != len);
 182
 183         buf[len] = 0;
 184
 185         debug_printf("DEBUG: %s\n", buf);
 186
 187         if (command == 0xd6) {
 188                 res = g_strsplit(buf, " ", 0);
 189                 /* Do we want to report what the users are doing? */
 190                 printf("users: %s, files: %s, size: %sGB\n", res[0], res[1], res[2]);
 191                 g_strfreev(res);
 192                 g_free(buf);
 193                 return;
 194         }
 195
 196         if (command == 0x26d) {
 197                 /* Do we want to use the MOTD? */
 198                 g_free(buf);
 199                 return;
 200         }
 201
 202         if (command == 0xCD) {
 203                 res = g_strsplit(buf, " ", 1);
 204                 serv_got_im(gc, res[0], res[1], 0, time(NULL), -1);
 205                 g_strfreev(res);
 206                 g_free(buf);
 207                 return;
 208         }
 209
 210         if (command == 0x195) {
 211                 struct nap_channel *channel;
 212
 213                 channel = find_channel_by_name(gc, buf);
 214
 215                 if (!channel) {
 216                         chat_id++;
 217
 218                         channel = g_new0(struct nap_channel, 1);
 219
 220                         channel->id = chat_id;
 221                         channel->name = g_strdup(buf);
 222
 223                         ndata->channels = g_slist_append(ndata->channels, channel);
 224
 225                         serv_got_joined_chat(gc, chat_id, buf);
 226                 }
 227
 228                 g_free(buf);
 229                 return;
 230         }
 231
 232         if (command == 0x198 || command == 0x196) {
 233                 struct nap_channel *channel;
 234                 struct conversation *convo;
 235                 gchar **res;
 236
 237                 res = g_strsplit(buf, " ", 0);
 238
 239                 channel = find_channel_by_name(gc, res[0]);
 240                 convo = find_conversation_by_id(gc, channel->id);
 241
 242                 add_chat_buddy(convo, res[1]);
 243
 244                 g_strfreev(res);
 245
 246                 g_free(buf);
 247                 return;
 248         }
 249
 250         if (command == 0x197) {
 251                 struct nap_channel *channel;
 252                 struct conversation *convo;
 253                 gchar **res;
 254
 255                 res = g_strsplit(buf, " ", 0);
 256
 257                 channel = find_channel_by_name(gc, res[0]);
 258                 convo = find_conversation_by_id(gc, channel->id);
 259
 260                 remove_chat_buddy(convo, res[1], NULL);
 261
 262                 g_strfreev(res);
 263                 g_free(buf);
 264                 return;
 265         }
 266
 267         if (command == 0x193) {
 268                 gchar **res;
 269                 struct nap_channel *channel;
 270
 271                 res = g_strsplit(buf, " ", 2);
 272
 273                 channel = find_channel_by_name(gc, res[0]);
 274
 275                 if (channel)
 276                         serv_got_chat_in(gc, channel->id, res[1], 0, res[2], time((time_t)NULL));
 277
 278                 g_strfreev(res);
 279                 g_free(buf);
 280                 return;
 281         }
 282
 283         if (command == 0x194) {
 284                 do_error_dialog(buf, "Gaim: Napster Error");
 285                 g_free(buf);
 286                 return;
 287         }
 288
 289         if (command == 0x12e) {
 290                 gchar buf2[NAP_BUF_LEN];
 291
 292                 g_snprintf(buf2, NAP_BUF_LEN, "Unable to add '%s' to your hotlist", buf);
 293                 do_error_dialog(buf2, "Gaim: Napster Error");
 294
 295                 g_free(buf);
 296                 return;
 297
 298         }
 299
 300         if (command == 0x191) {
 301                 struct nap_channel *channel;
 302
 303                 channel = find_channel_by_name(gc, buf);
 304
 305                 if (!channel) /* I'm not sure how this would happen =) */
 306                         return;
 307
 308                 serv_got_chat_left(gc, channel->id);
 309                 ndata->channels = g_slist_remove(ndata->channels, channel);
 310
 311                 g_free(buf);
 312                 return;
 313
 314         }
 315
 316         if (command == 0xd1) {
 317                 gchar **res;
 318
 319                 res = g_strsplit(buf, " ", 0);
 320
 321                 serv_got_update(gc, res[0], 1, 0, 0, 0, 0, 0);
 322
 323                 g_strfreev(res);
 324                 g_free(buf);
 325                 return;
 326         }
 327
 328         if (command == 0xd2) {
 329                 serv_got_update(gc, buf, 0, 0, 0, 0, 0, 0);
 330                 g_free(buf);
 331                 return;
 332         }
 333
 334         if (command == 0x12d) {
 335                 /* Our buddy was added successfully */
 336                 g_free(buf);
 337                 return;
 338         }
 339
 340         if (command == 0x2ec) {
 341                 /* Looks like someone logged in as us! =-O */
 342                 g_free(buf);
 343
 344                 signoff(gc);
 345                 return;
 346         }
 347
 348         debug_printf("NAP: [COMMAND: 0x%04x] %s\n", command, buf);
 349
 350         g_free(buf);
 351 }
 352
 353
 354 static void nap_login_callback(gpointer data, gint source, GaimInputCondition condition)
 355 {
 356         struct gaim_connection *gc = data;
 357         struct nap_data *ndata = gc->proto_data;
 358         gchar buf[NAP_BUF_LEN];
 359         unsigned short header[2];
 360         int len;
 361         int command;
 362
 363         read(source, header, 4);
 364         len = header[0];
 365         command = header[1];
 366
 367         read(source, buf, len);
 368         buf[len] = 0;
 369
 370         /* If we have some kind of error, get outta here */
 371         if (command == 0x00)
 372         {
 373                 do_error_dialog(buf, "Gaim: Napster Error");
 374                 gaim_input_remove(ndata->inpa);
 375                 ndata->inpa = 0;
 376                 close(source);
 377                 signoff(gc);
 378                 return;
 379         }
 380
 381         if (command == 0x03) {
 382                 printf("Registered with E-Mail address of: %s\n", buf);
 383                 ndata->email = g_strdup(buf);
 384
 385                 /* Remove old inpa, add new one */
 386                 gaim_input_remove(ndata->inpa);
 387                 ndata->inpa = 0;
 388                 gc->inpa = gaim_input_add(ndata->fd, GAIM_INPUT_READ, nap_callback, gc);
 389
 390                 /* Our signon is complete */
 391                 account_online(gc);
 392                 serv_finish_login(gc);
 393
 394                 if (bud_list_cache_exists(gc))
 395                         do_import(gc, NULL);
 396
 397                 return;
 398         }
 399 }
 400
 401
 402 static void nap_login_connect(gpointer data, gint source, GaimInputCondition cond)
 403 {
 404         struct gaim_connection *gc = data;
 405         struct nap_data *ndata;
 406         char buf[NAP_BUF_LEN];
 407
 408         if (!g_slist_find(connections, gc)) {
 409                 close(source);
 410                 return;
 411         }
 412
 413         if (source < 0) {
 414                 hide_login_progress(gc, "Unable to connect");
 415                 signoff(gc);
 416                 return;
 417         }
 418
 419         ndata = gc->proto_data;
 420         if (ndata->fd != source)
 421                 ndata->fd = source;
 422
 423         /* And write our signon data */
 424         g_snprintf(buf, NAP_BUF_LEN, "%s %s 0 \"gaimster\" 0", gc->username, gc->password);
 425         nap_write_packet(gc, 0x02, buf);
 426
 427         /* And set up the input watcher */
 428         ndata->inpa = gaim_input_add(ndata->fd, GAIM_INPUT_READ, nap_login_callback, gc);
 429 }
 430
 431
 432 static void nap_login(struct aim_user *user)
 433 {
 434         struct gaim_connection *gc = new_gaim_conn(user);
 435         struct nap_data *ndata = gc->proto_data = g_new0(struct nap_data, 1);
 436
 437         ndata->fd = proxy_connect("64.124.41.187", 8888, nap_login_connect, gc);
 438         if (ndata->fd < 0) {
 439                 hide_login_progress(gc, "Unable to connect");
 440                 signoff(gc);
 441         }
 442 }
 443
 444 static GList *nap_chat_info(struct gaim_connection *gc)
 445 {
 446         GList *m = NULL;
 447         struct proto_chat_entry *pce;
 448
 449         pce = g_new0(struct proto_chat_entry, 1);
 450         pce->label = _("Join what group:");
 451         m = g_list_append(m, pce);
 452
 453         return m;
 454 }
 455
 456 static void nap_join_chat(struct gaim_connection *gc, GList *data)
 457 {
 458         gchar buf[NAP_BUF_LEN];
 459         char *name;
 460
 461         if (!data)
 462                 return;
 463
 464         name = data->data;
 465
 466         /* Make sure the name has a # preceeding it */
 467         if (name[0] != '#')
 468                 g_snprintf(buf, NAP_BUF_LEN, "#%s", name);
 469         else
 470                 g_snprintf(buf, NAP_BUF_LEN, "%s", name);
 471
 472         nap_write_packet(gc, 0x190, buf);
 473 }
 474
 475 static void nap_chat_leave(struct gaim_connection *gc, int id)
 476 {
 477         struct nap_data *ndata = (struct nap_data *)gc->proto_data;
 478         struct nap_channel *channel = NULL;
 479
 480         channel = find_channel_by_id(gc, id);
 481
 482         if (!channel) /* Again, I'm not sure how this would happen */
 483                 return;
 484
 485         nap_write_packet(gc, 0x191, channel->name);
 486
 487         ndata->channels = g_slist_remove(ndata->channels, channel);
 488         g_free(channel->name);
 489         g_free(channel);
 490
 491 }
 492
 493 static int nap_chat_send(struct gaim_connection *gc, int id, char *message)
 494 {
 495         struct nap_channel *channel = NULL;
 496         gchar buf[NAP_BUF_LEN];
 497
 498         channel = find_channel_by_id(gc, id);
 499
 500         if (!channel) {
 501                 /* This shouldn't happen */
 502                 return -EINVAL;
 503         }
 504
 505         g_snprintf(buf, NAP_BUF_LEN, "%s %s", channel->name, message);
 506         nap_write_packet(gc, 0x192, buf);
 507         return 0;
 508 }
 509
 510 static void nap_add_buddy(struct gaim_connection *gc, char *name)
 511 {
 512         nap_write_packet(gc, 0xCF, name);
 513 }
 514
 515 static void nap_remove_buddy(struct gaim_connection *gc, char *name, char *group)
 516 {
 517         nap_write_packet(gc, 0x12F, name);
 518 }
 519
 520 static void nap_close(struct gaim_connection *gc)
 521 {
 522         struct nap_data *ndata = (struct nap_data *)gc->proto_data;
 523         struct nap_channel *channel;
 524
 525         if (gc->inpa)
 526                 gaim_input_remove(gc->inpa);
 527
 528         while (ndata->channels) {
 529                 channel = (struct nap_channel *)ndata->channels->data;
 530                 g_free(channel->name);
 531                 ndata->channels = g_slist_remove(ndata->channels, channel);
 532                 g_free(channel);
 533         }
 534
 535         g_free(gc->proto_data);
 536 }
 537
 538 static void nap_add_buddies(struct gaim_connection *gc, GList *buddies)
 539 {
 540         while (buddies) {
 541                 nap_write_packet(gc, 0xd0, (char *)buddies->data);
 542                 buddies = buddies -> next;
 543         }
 544 }
 545
 546 static char** nap_list_icon(int uc)
 547 {
 548         return napster_xpm;
 549 }
 550
 551 static struct prpl *my_protocol = NULL;
 552
 553 void napster_init(struct prpl *ret)
 554 {
 555         ret->protocol = PROTO_NAPSTER;
 556         ret->name = nap_name;
 557         ret->list_icon = nap_list_icon;
 558         ret->user_opts = NULL;
 559         ret->login = nap_login;
 560         ret->close = nap_close;
 561         ret->send_im = nap_send_im;
 562         ret->set_info = NULL;
 563         ret->get_info = NULL;
 564         ret->set_away = NULL;
 565         ret->set_dir = NULL;
 566         ret->get_dir = NULL;
 567         ret->dir_search = NULL;
 568         ret->set_idle = NULL;
 569         ret->change_passwd = NULL;
 570         ret->add_buddy = nap_add_buddy;
 571         ret->add_buddies = nap_add_buddies;
 572         ret->remove_buddy = nap_remove_buddy;
 573         ret->add_permit = NULL;
 574         ret->rem_permit = NULL;
 575         ret->add_deny = NULL;
 576         ret->rem_deny = NULL;
 577         ret->warn = NULL;
 578         ret->chat_info = nap_chat_info;
 579         ret->join_chat = nap_join_chat;
 580         ret->chat_invite = NULL;
 581         ret->chat_leave = nap_chat_leave;
 582         ret->chat_whisper = NULL;
 583         ret->chat_send = nap_chat_send;
 584         ret->keepalive = NULL;
 585
 586         my_protocol = ret;
 587 }
 588
 589 #ifndef STATIC
 590
 591 char *gaim_plugin_init(GModule * handle)
 592 {
 593         load_protocol(napster_init, sizeof(struct prpl));
 594         return NULL;
 595 }
 596
 597 void gaim_plugin_remove()
 598 {
 599         struct prpl *p = find_prpl(PROTO_NAPSTER);
 600         if (p == my_protocol)
 601                 unload_protocol(p);
 602 }
 603
 604 char *name()
 605 {
 606         return "Napster";
 607 }
 608
 609 char *description()
 610 {
 611         return PRPL_DESC("Napster");
 612 }
 613
 614 #endif