src/list.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 <string.h>
  26 #include <sys/types.h>
  27 #include <sys/stat.h>
  28 #include <unistd.h>
  29 #include "gaim.h"
  30 #include "prpl.h"
  31
  32 #define PATHSIZE 1024
  33
  34 void remove_buddy(struct gaim_connection *gc, struct group *rem_g, struct buddy *rem_b)
  35 {
  36         GSList *grp;
  37         GSList *mem;
  38
  39         struct group *delg;
  40         struct buddy *delb;
  41
  42         /* we assume that gc is not NULL and that the buddy exists somewhere within the
  43          * gc's buddy list, therefore we can safely remove it. we need to ensure this
  44          * via the UI
  45          */
  46
  47         grp = g_slist_find(gc->groups, rem_g);
  48         delg = (struct group *)grp->data;
  49         mem = delg->members;
  50
  51         mem = g_slist_find(mem, rem_b);
  52         delb = (struct buddy *)mem->data;
  53
  54         delg->members = g_slist_remove(delg->members, delb);
  55
  56         ui_remove_buddy(gc, rem_g, rem_b);
  57
  58         g_free(rem_b);
  59
  60         /* we don't flush buddy list to cache because in the case of remove_group that would
  61          * mean writing to the buddy list file once for each buddy, plus one more time */
  62 }
  63
  64 void remove_group(struct gaim_connection *gc, struct group *rem_g)
  65 {
  66         GSList *grp;
  67         GSList *mem;
  68         GList *tmp = NULL;
  69
  70         struct group *delg;
  71         struct buddy *delb;
  72
  73         /* we assume that the group actually does exist within the gc, and that the gc is not NULL.
  74          * the UI is responsible for this */
  75
  76         grp = g_slist_find(gc->groups, rem_g);
  77         delg = (struct group *)grp->data;
  78         mem = delg->members;
  79
  80         while (delg->members) {
  81                 delb = (struct buddy *)delg->members->data;
  82                 tmp = g_list_append(tmp, g_strdup(delb->name));
  83                 remove_buddy(gc, delg, delb);   /* this should take care of removing
  84                                                    the group_show if necessary */
  85         }
  86
  87         gc->groups = g_slist_remove(gc->groups, delg);
  88
  89         serv_remove_buddies(gc, tmp, rem_g->name);
  90         while (tmp) {
  91                 g_free(tmp->data);
  92                 tmp = g_list_remove(tmp, tmp->data);
  93         }
  94
  95         ui_remove_group(gc, rem_g);
  96
  97         g_free(rem_g);
  98
  99         /* don't flush buddy list to cache in order to be consistent with remove_buddy,
 100          * mostly. remove_group is only called from one place, so we'll let it handle it. */
 101 }
 102
 103 struct buddy *add_buddy(struct gaim_connection *gc, char *group, char *buddy, char *show)
 104 {
 105         struct buddy *b;
 106         struct group *g;
 107         char *good;
 108
 109         if (!g_slist_find(connections, gc))
 110                 return NULL;
 111
 112         if ((b = find_buddy(gc, buddy)) != NULL)
 113                 return b;
 114
 115         g = find_group(gc, group);
 116
 117         if (g == NULL)
 118                 g = add_group(gc, group);
 119
 120         b = (struct buddy *)g_new0(struct buddy, 1);
 121
 122         if (!b)
 123                 return NULL;
 124
 125         b->gc = gc;
 126         b->present = 0;
 127
 128         if (gc->prpl->normalize)
 129                 good = gc->prpl->normalize(buddy);
 130         else
 131                 good = buddy;
 132
 133         g_snprintf(b->name, sizeof(b->name), "%s", good);
 134         g_snprintf(b->show, sizeof(b->show), "%s", show ? (show[0] ? show : good) : good);
 135
 136         g->members = g_slist_append(g->members, b);
 137
 138         b->idle = 0;
 139         b->caps = 0;
 140
 141         ui_add_buddy(gc, g, b);
 142
 143         return b;
 144 }
 145
 146 struct group *add_group(struct gaim_connection *gc, char *group)
 147 {
 148         struct group *g = find_group(gc, group);
 149         if (g)
 150                 return g;
 151         if (!g_slist_find(connections, gc))
 152                 return NULL;
 153         g = (struct group *)g_new0(struct group, 1);
 154         if (!g)
 155                 return NULL;
 156
 157         g->gc = gc;
 158         strncpy(g->name, group, sizeof(g->name));
 159         gc->groups = g_slist_append(gc->groups, g);
 160
 161         g->members = NULL;
 162
 163         ui_add_group(gc, g);
 164
 165         return g;
 166 }
 167
 168 struct group *find_group(struct gaim_connection *gc, char *group)
 169 {
 170         struct group *g;
 171         GSList *grp;
 172         GSList *c = connections;
 173         struct gaim_connection *z;
 174         char *grpname = g_malloc(strlen(group) + 1);
 175
 176         strcpy(grpname, normalize (group));
 177         if (gc) {
 178                 if (!g_slist_find(connections, gc))
 179                         return NULL;
 180                 grp = gc->groups;
 181                 while (grp) {
 182                         g = (struct group *)grp->data;
 183                         if (!g_strcasecmp(normalize (g->name), grpname)) {
 184                                 g_free(grpname);
 185                                 return g;
 186                         }
 187                         grp = g_slist_next(grp);
 188                 }
 189
 190                 g_free(grpname);
 191                 return NULL;
 192         } else {
 193                 while (c) {
 194                         z = (struct gaim_connection *)c->data;
 195                         grp = z->groups;
 196                         while (grp) {
 197                                 g = (struct group *)grp->data;
 198                                 if (!g_strcasecmp(normalize (g->name), grpname)) {
 199                                         g_free(grpname);
 200                                         return g;
 201                                 }
 202                                 grp = g_slist_next(grp);
 203                         }
 204
 205                         c = c->next;
 206                 }
 207                 g_free(grpname);
 208                 return NULL;
 209         }
 210 }
 211
 212 struct group *find_group_by_buddy(struct gaim_connection *gc, char *who)
 213 {
 214         struct group *g;
 215         struct buddy *b;
 216         GSList *grp;
 217         GSList *mem;
 218         char *whoname;
 219         char *(*norm)(const char *);
 220
 221         if (gc) {
 222                 if (gc->prpl->normalize)
 223                         norm = gc->prpl->normalize;
 224                 else
 225                         norm = normalize;
 226                 whoname = g_strdup(norm(who));
 227                 grp = gc->groups;
 228                 while (grp) {
 229                         g = (struct group *)grp->data;
 230
 231                         mem = g->members;
 232                         while (mem) {
 233                                 b = (struct buddy *)mem->data;
 234                                 if (!strcmp(norm(b->name), whoname)) {
 235                                         g_free(whoname);
 236                                         return g;
 237                                 }
 238                                 mem = mem->next;
 239                         }
 240                         grp = g_slist_next(grp);
 241                 }
 242                 g_free(whoname);
 243                 return NULL;
 244         } else {
 245                 GSList *c = connections;
 246                 struct gaim_connection *z;
 247                 while (c) {
 248                         z = (struct gaim_connection *)c->data;
 249                         if (z->prpl->normalize)
 250                                 norm = z->prpl->normalize;
 251                         else
 252                                 norm = normalize;
 253                         whoname = g_strdup(norm(who));
 254                         grp = z->groups;
 255                         while (grp) {
 256                                 g = (struct group *)grp->data;
 257
 258                                 mem = g->members;
 259                                 while (mem) {
 260                                         b = (struct buddy *)mem->data;
 261                                         if (!strcmp(norm(b->name), whoname)) {
 262                                                 g_free(whoname);
 263                                                 return g;
 264                                         }
 265                                         mem = mem->next;
 266                                 }
 267                                 grp = g_slist_next(grp);
 268                         }
 269                         c = c->next;
 270                         g_free(whoname);
 271                 }
 272                 return NULL;
 273         }
 274 }
 275
 276 struct buddy *find_buddy(struct gaim_connection *gc, char *who)
 277 {
 278         struct group *g;
 279         struct buddy *b;
 280         GSList *grp;
 281         GSList *c;
 282         struct gaim_connection *z;
 283         GSList *mem;
 284         char *whoname;
 285         char *(*norm)(const char *);
 286
 287         if (gc) {
 288                 if (!g_slist_find(connections, gc))
 289                         return NULL;
 290                 if (gc->prpl->normalize)
 291                         norm = gc->prpl->normalize;
 292                 else
 293                         norm = normalize;
 294                 whoname = g_strdup(norm(who));
 295                 grp = gc->groups;
 296                 while (grp) {
 297                         g = (struct group *)grp->data;
 298
 299                         mem = g->members;
 300                         while (mem) {
 301                                 b = (struct buddy *)mem->data;
 302                                 if (!strcmp(norm(b->name), whoname)) {
 303                                         g_free(whoname);
 304                                         return b;
 305                                 }
 306                                 mem = mem->next;
 307                         }
 308                         grp = g_slist_next(grp);
 309                 }
 310                 g_free(whoname);
 311                 return NULL;
 312         } else {
 313                 c = connections;
 314                 while (c) {
 315                         z = (struct gaim_connection *)c->data;
 316                         if (z->prpl->normalize)
 317                                 norm = z->prpl->normalize;
 318                         else
 319                                 norm = normalize;
 320                         whoname = g_strdup(norm(who));
 321                         grp = z->groups;
 322                         while (grp) {
 323                                 g = (struct group *)grp->data;
 324
 325                                 mem = g->members;
 326                                 while (mem) {
 327                                         b = (struct buddy *)mem->data;
 328                                         if (!strcmp(norm(b->name), whoname)) {
 329                                                 g_free(whoname);
 330                                                 return b;
 331                                         }
 332                                         mem = mem->next;
 333                                 }
 334                                 grp = g_slist_next(grp);
 335                         }
 336                         c = c->next;
 337                         g_free(whoname);
 338                 }
 339                 return NULL;
 340         }
 341 }
 342
 343 void parse_toc_buddy_list(struct gaim_connection *gc, char *config)
 344 {
 345         char *c;
 346         char current[256];
 347         char *name;
 348         GList *bud;
 349         int how_many = 0;
 350
 351         bud = NULL;
 352
 353         if (config != NULL) {
 354
 355                 /* skip "CONFIG:" (if it exists) */
 356                 c = strncmp(config + 6 /* sizeof(struct sflap_hdr) */ , "CONFIG:", strlen("CONFIG:")) ?
 357                     strtok(config, "\n") :
 358                     strtok(config + 6 /* sizeof(struct sflap_hdr) */  + strlen("CONFIG:"), "\n");
 359                 do {
 360                         if (c == NULL)
 361                                 break;
 362                         if (*c == 'g') {
 363                                 strncpy(current, c + 2, sizeof(current));
 364                                 if (!find_group(gc, current)) {
 365                                         add_group(gc, current);
 366                                         how_many++;
 367                                 }
 368                         } else if (*c == 'b' && !find_buddy(gc, c + 2)) {
 369                                 char nm[80], sw[388], *tmp = c + 2;
 370                                 int i = 0;
 371                                 while (*tmp != ':' && *tmp)
 372                                         nm[i++] = *tmp++;
 373                                 if (*tmp == ':')
 374                                         *tmp++ = '\0';
 375                                 nm[i] = '\0';
 376                                 i = 0;
 377                                 while (*tmp)
 378                                         sw[i++] = *tmp++;
 379                                 sw[i] = '\0';
 380                                 if (!find_buddy(gc, nm)) {
 381                                         add_buddy(gc, current, nm, sw);
 382                                         how_many++;
 383                                         bud = g_list_append(bud, c + 2);
 384                                 }
 385                         } else if (*c == 'p') {
 386                                 GSList *d = gc->permit;
 387                                 char *n;
 388                                 name = g_malloc(strlen(c + 2) + 2);
 389                                 g_snprintf(name, strlen(c + 2) + 1, "%s", c + 2);
 390                                 n = g_strdup(normalize (name));
 391                                 while (d) {
 392                                         if (!g_strcasecmp(n, normalize (d->data)))
 393                                                  break;
 394                                         d = d->next;
 395                                 }
 396                                 g_free(n);
 397                                 if (!d) {
 398                                         gc->permit = g_slist_append(gc->permit, name);
 399                                         how_many++;
 400                                 } else
 401                                         g_free(name);
 402                         } else if (*c == 'd') {
 403                                 GSList *d = gc->deny;
 404                                 char *n;
 405                                 name = g_malloc(strlen(c + 2) + 2);
 406                                 g_snprintf(name, strlen(c + 2) + 1, "%s", c + 2);
 407                                 n = g_strdup(normalize (name));
 408                                 while (d) {
 409                                         if (!g_strcasecmp(n, normalize (d->data)))
 410                                                  break;
 411                                         d = d->next;
 412                                 }
 413                                 g_free(n);
 414                                 if (!d) {
 415                                         gc->deny = g_slist_append(gc->deny, name);
 416                                         how_many++;
 417                                 } else
 418                                         g_free(name);
 419                         } else if (!strncmp("toc", c, 3)) {
 420                                 sscanf(c + strlen(c) - 1, "%d", &gc->permdeny);
 421                                 debug_printf("permdeny: %d\n", gc->permdeny);
 422                                 if (gc->permdeny == 0)
 423                                         gc->permdeny = 1;
 424                         } else if (*c == 'm') {
 425                                 sscanf(c + 2, "%d", &gc->permdeny);
 426                                 debug_printf("permdeny: %d\n", gc->permdeny);
 427                                 if (gc->permdeny == 0)
 428                                         gc->permdeny = 1;
 429                         }
 430                 } while ((c = strtok(NULL, "\n")));
 431
 432                 if (bud != NULL) {
 433                         serv_add_buddies(gc, bud);
 434                         g_list_free(bud);
 435                 }
 436                 serv_set_permit_deny(gc);
 437         }
 438
 439         if (how_many != 0)
 440                 do_export(gc);
 441 }
 442
 443 void toc_build_config(struct gaim_connection *gc, char *s, int len, gboolean show)
 444 {
 445         GSList *grp = gc->groups;
 446         GSList *mem;
 447         struct group *g;
 448         struct buddy *b;
 449         GSList *plist = gc->permit;
 450         GSList *dlist = gc->deny;
 451
 452         int pos = 0;
 453
 454         if (!gc->permdeny)
 455                 gc->permdeny = 1;
 456
 457         pos += g_snprintf(&s[pos], len - pos, "m %d\n", gc->permdeny);
 458         while (len > pos && grp) {
 459                 g = (struct group *)grp->data;
 460                 pos += g_snprintf(&s[pos], len - pos, "g %s\n", g->name);
 461                 mem = g->members;
 462                 while (len > pos && mem) {
 463                         b = (struct buddy *)mem->data;
 464                         pos += g_snprintf(&s[pos], len - pos, "b %s%s%s\n", b->name,
 465                                           (show && strcmp(b->name, b->show)) ? ":" : "",
 466                                           (show && strcmp(b->name, b->show)) ? b->show : "");
 467                         mem = mem->next;
 468                 }
 469                 grp = g_slist_next(grp);
 470         }
 471
 472         while (len > pos && plist) {
 473                 pos += g_snprintf(&s[pos], len - pos, "p %s\n", (char *)plist->data);
 474                 plist = plist->next;
 475         }
 476
 477         while (len > pos && dlist) {
 478                 pos += g_snprintf(&s[pos], len - pos, "d %s\n", (char *)dlist->data);
 479                 dlist = dlist->next;
 480         }
 481 }
 482
 483 /* translate an AIM 3 buddylist (*.lst) to a Gaim buddylist */
 484 static GString *translate_lst(FILE *src_fp)
 485 {
 486         char line[BUF_LEN], *line2;
 487         char *name;
 488         int i;
 489
 490         GString *dest = g_string_new("m 1\n");
 491
 492         while (fgets(line, BUF_LEN, src_fp)) {
 493                 line2 = g_strchug(line);
 494                 if (strstr(line2, "group") == line2) {
 495                         name = strpbrk(line2, " \t\n\r\f") + 1;
 496                         dest = g_string_append(dest, "g ");
 497                         for (i = 0; i < strcspn(name, "\n\r"); i++)
 498                                 if (name[i] != '\"')
 499                                         dest = g_string_append_c(dest, name[i]);
 500                         dest = g_string_append_c(dest, '\n');
 501                 }
 502                 if (strstr(line2, "buddy") == line2) {
 503                         name = strpbrk(line2, " \t\n\r\f") + 1;
 504                         dest = g_string_append(dest, "b ");
 505                         for (i = 0; i < strcspn(name, "\n\r"); i++)
 506                                 if (name[i] != '\"')
 507                                         dest = g_string_append_c(dest, name[i]);
 508                         dest = g_string_append_c(dest, '\n');
 509                 }
 510         }
 511
 512         return dest;
 513 }
 514
 515
 516 /* translate an AIM 4 buddylist (*.blt) to Gaim format */
 517 static GString *translate_blt(FILE *src_fp)
 518 {
 519         int i;
 520         char line[BUF_LEN];
 521         char *buddy;
 522
 523         GString *dest = g_string_new("m 1\n");
 524
 525         while (strstr(fgets(line, BUF_LEN, src_fp), "Buddy") == NULL);
 526         while (strstr(fgets(line, BUF_LEN, src_fp), "list") == NULL);
 527
 528         while (1) {
 529                 fgets(line, BUF_LEN, src_fp); g_strchomp(line);
 530                 if (strchr(line, '}') != NULL)
 531                         break;
 532
 533                 if (strchr(line, '{') != NULL) {
 534                         /* Syntax starting with "<group> {" */
 535
 536                         dest = g_string_append(dest, "g ");
 537                         buddy = g_strchug(strtok(line, "{"));
 538                         for (i = 0; i < strlen(buddy); i++)
 539                                 if (buddy[i] != '\"')
 540                                         dest = g_string_append_c(dest, buddy[i]);
 541                         dest = g_string_append_c(dest, '\n');
 542                         while (strchr(fgets(line, BUF_LEN, src_fp), '}') == NULL) {
 543                                 gboolean pounce = FALSE;
 544                                 char *e;
 545                                 g_strchomp(line);
 546                                 buddy = g_strchug(line);
 547                                 debug_printf("\nbuddy: \"%s\"\n\n", buddy);
 548                                 dest = g_string_append(dest, "b ");
 549                                 if (strchr(buddy, '{') != NULL) {
 550                                         /* buddy pounce, etc */
 551                                         char *pos = strchr(buddy, '{') - 1;
 552                                         *pos = 0;
 553                                         pounce = TRUE;
 554                                 }
 555                                 if ((e = strchr(buddy, '\"')) != NULL) {
 556                                         *e = '\0';
 557                                         buddy++;
 558                                 }
 559                                 dest = g_string_append(dest, buddy);
 560                                 dest = g_string_append_c(dest, '\n');
 561                                 if (pounce)
 562                                         do
 563                                                 fgets(line, BUF_LEN, src_fp);
 564                                         while (!strchr(line, '}'));
 565                         }
 566                 } else {
 567
 568                         /* Syntax "group buddy buddy ..." */
 569                         buddy = g_strchug(strtok(line, " \n"));
 570                         dest = g_string_append(dest, "g ");
 571                         if (strchr(buddy, '\"') != NULL) {
 572                                 dest = g_string_append(dest, &buddy[1]);
 573                                 dest = g_string_append_c(dest, ' ');
 574                                 buddy = g_strchug(strtok(NULL, " \n"));
 575                                 while (strchr(buddy, '\"') == NULL) {
 576                                         dest = g_string_append(dest, buddy);
 577                                         dest = g_string_append_c(dest, ' ');
 578                                         buddy = g_strchug(strtok(NULL, " \n"));
 579                                 }
 580                                 buddy[strlen(buddy) - 1] = '\0';
 581                                 dest = g_string_append(dest, buddy);
 582                         } else {
 583                                 dest = g_string_append(dest, buddy);
 584                         }
 585                         dest = g_string_append_c(dest, '\n');
 586                         while ((buddy = g_strchug(strtok(NULL, " \n"))) != NULL) {
 587                                 dest = g_string_append(dest, "b ");
 588                                 if (strchr(buddy, '\"') != NULL) {
 589                                         dest = g_string_append(dest, &buddy[1]);
 590                                         dest = g_string_append_c(dest, ' ');
 591                                         buddy = g_strchug(strtok(NULL, " \n"));
 592                                         while (strchr(buddy, '\"') == NULL) {
 593                                                 dest = g_string_append(dest, buddy);
 594                                                 dest = g_string_append_c(dest, ' ');
 595                                                 buddy = g_strchug(strtok(NULL, " \n"));
 596                                         }
 597                                         buddy[strlen(buddy) - 1] = '\0';
 598                                         dest = g_string_append(dest, buddy);
 599                                 } else {
 600                                         dest = g_string_append(dest, buddy);
 601                                 }
 602                                 dest = g_string_append_c(dest, '\n');
 603                         }
 604                 }
 605         }
 606
 607         return dest;
 608 }
 609
 610 static GString *translate_gnomeicu(FILE *src_fp)
 611 {
 612         char line[BUF_LEN];
 613         GString *dest = g_string_new("m 1\ng Buddies\n");
 614
 615         while (strstr(fgets(line, BUF_LEN, src_fp), "NewContacts") == NULL);
 616
 617         while (fgets(line, BUF_LEN, src_fp)) {
 618                 char *eq;
 619                 g_strchomp(line);
 620                 if (line[0] == '\n' || line[0] == '[')
 621                         break;
 622                 eq = strchr(line, '=');
 623                 if (!eq)
 624                         break;
 625                 *eq = ':';
 626                 eq = strchr(eq, ',');
 627                 if (eq)
 628                         *eq = '\0';
 629                 dest = g_string_append(dest, "b ");
 630                 dest = g_string_append(dest, line);
 631                 dest = g_string_append_c(dest, '\n');
 632         }
 633
 634         return dest;
 635 }
 636
 637 static gchar *get_screenname_filename(const char *name)
 638 {
 639         gchar **split;
 640         gchar *good;
 641
 642         split = g_strsplit(name, G_DIR_SEPARATOR_S, -1);
 643         good = g_strjoinv(NULL, split);
 644         g_strfreev(split);
 645
 646         g_strup(good);
 647
 648         return good;
 649 }
 650
 651 /* see if a buddy list cache file for this user exists */
 652
 653 gboolean bud_list_cache_exists(struct gaim_connection *gc)
 654 {
 655         gboolean ret = FALSE;
 656         char path[PATHSIZE];
 657         char *file;
 658         struct stat sbuf;
 659         char *g_screenname;
 660
 661         g_screenname = get_screenname_filename(gc->username);
 662
 663         file = gaim_user_dir();
 664         if (file != (char *)NULL) {
 665                 g_snprintf(path, sizeof path, "%s/%s.%d.blist", file, g_screenname, gc->protocol);
 666                 if (!stat(path, &sbuf)) {
 667                         debug_printf("%s exists.\n", path);
 668                         ret = TRUE;
 669                 } else {
 670                         char path2[PATHSIZE];
 671                         debug_printf("%s does not exist.\n", path);
 672                         g_snprintf(path2, sizeof path2, "%s/%s.blist", file, g_screenname);
 673                         if (!stat(path2, &sbuf)) {
 674                                 debug_printf("%s exists, moving to %s\n", path2, path);
 675                                 if (rename(path2, path))
 676                                         debug_printf("rename didn't work!\n");
 677                                 else
 678                                         ret = TRUE;
 679                         }
 680                 }
 681                 g_free(file);
 682         }
 683         g_free(g_screenname);
 684         return ret;
 685 }
 686
 687 void do_import(struct gaim_connection *gc, char *filename)
 688 {
 689         GString *buf = NULL;
 690         char first[64];
 691         char path[PATHSIZE];
 692         int len;
 693         FILE *f;
 694         struct stat st;
 695
 696         if (filename) {
 697                 g_snprintf(path, sizeof(path), "%s", filename);
 698         } else {
 699                 char *g_screenname = get_screenname_filename(gc->username);
 700                 char *file = gaim_user_dir();
 701
 702                 if (file != (char *)NULL) {
 703                         sprintf(path, "%s/%s.%d.blist", file, g_screenname, gc->protocol);
 704                         g_free(file);
 705                         g_free(g_screenname);
 706                 } else {
 707                         g_free(g_screenname);
 708                         return;
 709                 }
 710         }
 711
 712         if (stat(path, &st)) {
 713                 debug_printf("Unable to stat %s.\n", path);
 714                 return;
 715         }
 716
 717         if (!(f = fopen(path, "r"))) {
 718                 debug_printf("Unable to open %s.\n", path);
 719                 return;
 720         }
 721
 722         fgets(first, 64, f);
 723
 724         if ((first[0] == '\n') || (first[0] == '\r' && first[1] == '\n'))
 725                 fgets(first, 64, f);
 726
 727         if (!g_strncasecmp(first, "Config {", strlen("Config {"))) {
 728                 /* AIM 4 buddy list */
 729                 debug_printf("aim 4\n");
 730                 rewind(f);
 731                 buf = translate_blt(f);
 732         } else if (strstr(first, "group") != NULL) {
 733                 /* AIM 3 buddy list */
 734                 debug_printf("aim 3\n");
 735                 rewind(f);
 736                 buf = translate_lst(f);
 737         } else if (!g_strncasecmp(first, "[User]", strlen("[User]"))) {
 738                 /* GnomeICU (hopefully) */
 739                 debug_printf("gnomeicu\n");
 740                 rewind(f);
 741                 buf = translate_gnomeicu(f);
 742         } else if (first[0] == 'm') {
 743                 /* Gaim buddy list - no translation */
 744                 char buf2[BUF_LONG * 2];
 745                 buf = g_string_new("");
 746                 rewind(f);
 747                 while (1) {
 748                         len = fread(buf2, 1, BUF_LONG * 2 - 1, f);
 749                         if (len <= 0)
 750                                 break;
 751                         buf2[len] = '\0';
 752                         buf = g_string_append(buf, buf2);
 753                         if (len != BUF_LONG * 2 - 1)
 754                                 break;
 755                 }
 756         }
 757
 758         fclose(f);
 759
 760         if (buf) {
 761                 buf = g_string_prepend(buf, "toc_set_config {");
 762                 buf = g_string_append(buf, "}\n");
 763                 parse_toc_buddy_list(gc, buf->str);
 764                 g_string_free(buf, TRUE);
 765         }
 766 }
 767
 768 void do_export(struct gaim_connection *g)
 769 {
 770         FILE *dir;
 771         FILE *f;
 772         char buf[32 * 1024];
 773         char *file;
 774         char path[PATHSIZE];
 775         char *g_screenname;
 776
 777         file = gaim_user_dir();
 778         if (!file)
 779                 return;
 780
 781         strcpy(buf, file);
 782         dir = fopen(buf, "r");
 783         if (!dir)
 784                 mkdir(buf, S_IRUSR | S_IWUSR | S_IXUSR);
 785         else
 786                 fclose(dir);
 787
 788         g_screenname = get_screenname_filename(g->username);
 789
 790         sprintf(path, "%s/%s.%d.blist", file, g_screenname, g->protocol);
 791         if ((f = fopen(path, "w"))) {
 792                 debug_printf("writing %s\n", path);
 793                 toc_build_config(g, buf, 8192 - 1, TRUE);
 794                 fprintf(f, "%s\n", buf);
 795                 fclose(f);
 796                 chmod(buf, S_IRUSR | S_IWUSR);
 797         } else {
 798                 debug_printf("unable to write %s\n", path);
 799         }
 800
 801         g_free(g_screenname);
 802         g_free(file);
 803 }
 804
 805 static gboolean is_blocked(struct buddy *b)
 806 {
 807         struct gaim_connection *gc = b->gc;
 808
 809         if (gc->permdeny == PERMIT_ALL)
 810                 return FALSE;
 811
 812         if (gc->permdeny == PERMIT_NONE) {
 813                 if (g_strcasecmp(b->name, gc->displayname))
 814                         return TRUE;
 815                 else
 816                         return FALSE;
 817         }
 818
 819         if (gc->permdeny == PERMIT_SOME) {
 820                 char *x = g_strdup(normalize(b->name));
 821                 GSList *s = gc->permit;
 822                 while (s) {
 823                         if (!g_strcasecmp(x, normalize(s->data)))
 824                                 break;
 825                         s = s->next;
 826                 }
 827                 g_free(x);
 828                 if (s)
 829                         return FALSE;
 830                 return TRUE;
 831         }
 832
 833         if (gc->permdeny == DENY_SOME) {
 834                 char *x = g_strdup(normalize(b->name));
 835                 GSList *s = gc->deny;
 836                 while (s) {
 837                         if (!g_strcasecmp(x, normalize(s->data)))
 838                                 break;
 839                         s = s->next;
 840                 }
 841                 g_free(x);
 842                 if (s)
 843                         return TRUE;
 844                 return FALSE;
 845         }
 846
 847         return FALSE;
 848 }
 849
 850 void signoff_blocked(struct gaim_connection *gc)
 851 {
 852         GSList *g = gc->groups;
 853         while (g) {
 854                 GSList *m = ((struct group *)g->data)->members;
 855                 while (m) {
 856                         struct buddy *b = m->data;
 857                         if (is_blocked(b))
 858                                 serv_got_update(gc, b->name, 0, 0, 0, 0, 0, 0);
 859                         m = m->next;
 860                 }
 861                 g = g->next;
 862         }
 863 }