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 && i < sizeof(nm) - 1)
 372                                         nm[i++] = *tmp++;
 373
 374                                 while (*tmp != ':' && *tmp)
 375                                         tmp++;
 376
 377                                 if (*tmp == ':')
 378                                         *tmp++ = '\0';
 379
 380                                 nm[i] = '\0';
 381                                 i = 0;
 382                                 while (*tmp && i < sizeof(sw) - 1)
 383                                         sw[i++] = *tmp++;
 384                                 sw[i] = '\0';
 385                                 if (!find_buddy(gc, nm)) {
 386                                         add_buddy(gc, current, nm, sw);
 387                                         how_many++;
 388                                         bud = g_list_append(bud, c + 2);
 389                                 }
 390                         } else if (*c == 'p') {
 391                                 GSList *d = gc->permit;
 392                                 char *n;
 393                                 name = g_malloc(strlen(c + 2) + 2);
 394                                 g_snprintf(name, strlen(c + 2) + 1, "%s", c + 2);
 395                                 n = g_strdup(normalize (name));
 396                                 while (d) {
 397                                         if (!g_strcasecmp(n, normalize (d->data)))
 398                                                 break;
 399                                         d = d->next;
 400                                 }
 401                                 g_free(n);
 402                                 if (!d) {
 403                                         gc->permit = g_slist_append(gc->permit, name);
 404                                         how_many++;
 405                                 } else
 406                                         g_free(name);
 407                         } else if (*c == 'd') {
 408                                 GSList *d = gc->deny;
 409                                 char *n;
 410                                 name = g_malloc(strlen(c + 2) + 2);
 411                                 g_snprintf(name, strlen(c + 2) + 1, "%s", c + 2);
 412                                 n = g_strdup(normalize (name));
 413                                 while (d) {
 414                                         if (!g_strcasecmp(n, normalize (d->data)))
 415                                         break;
 416                                 d = d->next;
 417                         }
 418                         g_free(n);
 419                         if (!d) {
 420                                 gc->deny = g_slist_append(gc->deny, name);
 421                                 how_many++;
 422                         } else
 423                                 g_free(name);
 424                         } else if (!strncmp("toc", c, 3)) {
 425                                 sscanf(c + strlen(c) - 1, "%d", &gc->permdeny);
 426                                 debug_printf("permdeny: %d\n", gc->permdeny);
 427                                 if (gc->permdeny == 0)
 428                                         gc->permdeny = 1;
 429                         } else if (*c == 'm') {
 430                                 sscanf(c + 2, "%d", &gc->permdeny);
 431                                 debug_printf("permdeny: %d\n", gc->permdeny);
 432                                 if (gc->permdeny == 0)
 433                                         gc->permdeny = 1;
 434                         }
 435                 } while ((c = strtok(NULL, "\n")));
 436
 437                 if (bud != NULL) {
 438                         serv_add_buddies(gc, bud);
 439                         g_list_free(bud);
 440                 }
 441                 serv_set_permit_deny(gc);
 442         }
 443
 444         if (how_many != 0)
 445                 do_export(gc);
 446
 447 }
 448
 449 void toc_build_config(struct gaim_connection *gc, char *s, int len, gboolean show)
 450 {
 451         GSList *grp = gc->groups;
 452         GSList *mem;
 453         struct group *g;
 454         struct buddy *b;
 455         GSList *plist = gc->permit;
 456         GSList *dlist = gc->deny;
 457
 458         int pos = 0;
 459
 460         if (!gc->permdeny)
 461                 gc->permdeny = 1;
 462
 463         pos += g_snprintf(&s[pos], len - pos, "m %d\n", gc->permdeny);
 464         while (len > pos && grp) {
 465                 g = (struct group *)grp->data;
 466                 pos += g_snprintf(&s[pos], len - pos, "g %s\n", g->name);
 467                 mem = g->members;
 468                 while (len > pos && mem) {
 469                         b = (struct buddy *)mem->data;
 470                         pos += g_snprintf(&s[pos], len - pos, "b %s%s%s\n", b->name,
 471                                           (show && strcmp(b->name, b->show)) ? ":" : "",
 472                                           (show && strcmp(b->name, b->show)) ? b->show : "");
 473                         mem = mem->next;
 474                 }
 475                 grp = g_slist_next(grp);
 476         }
 477
 478         while (len > pos && plist) {
 479                 pos += g_snprintf(&s[pos], len - pos, "p %s\n", (char *)plist->data);
 480                 plist = plist->next;
 481         }
 482
 483         while (len > pos && dlist) {
 484                 pos += g_snprintf(&s[pos], len - pos, "d %s\n", (char *)dlist->data);
 485                 dlist = dlist->next;
 486         }
 487 }
 488
 489 /* translate an AIM 3 buddylist (*.lst) to a Gaim buddylist */
 490 static GString *translate_lst(FILE *src_fp)
 491 {
 492         char line[BUF_LEN], *line2;
 493         char *name;
 494         int i;
 495
 496         GString *dest = g_string_new("m 1\n");
 497
 498         while (fgets(line, BUF_LEN, src_fp)) {
 499                 line2 = g_strchug(line);
 500                 if (strstr(line2, "group") == line2) {
 501                         name = strpbrk(line2, " \t\n\r\f") + 1;
 502                         dest = g_string_append(dest, "g ");
 503                         for (i = 0; i < strcspn(name, "\n\r"); i++)
 504                                 if (name[i] != '\"')
 505                                         dest = g_string_append_c(dest, name[i]);
 506                         dest = g_string_append_c(dest, '\n');
 507                 }
 508                 if (strstr(line2, "buddy") == line2) {
 509                         name = strpbrk(line2, " \t\n\r\f") + 1;
 510                         dest = g_string_append(dest, "b ");
 511                         for (i = 0; i < strcspn(name, "\n\r"); i++)
 512                                 if (name[i] != '\"')
 513                                         dest = g_string_append_c(dest, name[i]);
 514                         dest = g_string_append_c(dest, '\n');
 515                 }
 516         }
 517
 518         return dest;
 519 }
 520
 521
 522 /* translate an AIM 4 buddylist (*.blt) to Gaim format */
 523 static GString *translate_blt(FILE *src_fp)
 524 {
 525         int i;
 526         char line[BUF_LEN];
 527         char *buddy;
 528
 529         GString *dest = g_string_new("m 1\n");
 530
 531         while (strstr(fgets(line, BUF_LEN, src_fp), "Buddy") == NULL);
 532         while (strstr(fgets(line, BUF_LEN, src_fp), "list") == NULL);
 533
 534         while (1) {
 535                 fgets(line, BUF_LEN, src_fp); g_strchomp(line);
 536                 if (strchr(line, '}') != NULL)
 537                         break;
 538
 539                 if (strchr(line, '{') != NULL) {
 540                         /* Syntax starting with "<group> {" */
 541
 542                         dest = g_string_append(dest, "g ");
 543                         buddy = g_strchug(strtok(line, "{"));
 544                         for (i = 0; i < strlen(buddy); i++)
 545                                 if (buddy[i] != '\"')
 546                                         dest = g_string_append_c(dest, buddy[i]);
 547                         dest = g_string_append_c(dest, '\n');
 548                         while (strchr(fgets(line, BUF_LEN, src_fp), '}') == NULL) {
 549                                 gboolean pounce = FALSE;
 550                                 char *e;
 551                                 g_strchomp(line);
 552                                 buddy = g_strchug(line);
 553                                 debug_printf("\nbuddy: \"%s\"\n\n", buddy);
 554                                 dest = g_string_append(dest, "b ");
 555                                 if (strchr(buddy, '{') != NULL) {
 556                                         /* buddy pounce, etc */
 557                                         char *pos = strchr(buddy, '{') - 1;
 558                                         *pos = 0;
 559                                         pounce = TRUE;
 560                                 }
 561                                 if ((e = strchr(buddy, '\"')) != NULL) {
 562                                         *e = '\0';
 563                                         buddy++;
 564                                 }
 565                                 dest = g_string_append(dest, buddy);
 566                                 dest = g_string_append_c(dest, '\n');
 567                                 if (pounce)
 568                                         do
 569                                                 fgets(line, BUF_LEN, src_fp);
 570                                         while (!strchr(line, '}'));
 571                         }
 572                 } else {
 573
 574                         /* Syntax "group buddy buddy ..." */
 575                         buddy = g_strchug(strtok(line, " \n"));
 576                         dest = g_string_append(dest, "g ");
 577                         if (strchr(buddy, '\"') != NULL) {
 578                                 dest = g_string_append(dest, &buddy[1]);
 579                                 dest = g_string_append_c(dest, ' ');
 580                                 buddy = g_strchug(strtok(NULL, " \n"));
 581                                 while (strchr(buddy, '\"') == NULL) {
 582                                         dest = g_string_append(dest, buddy);
 583                                         dest = g_string_append_c(dest, ' ');
 584                                         buddy = g_strchug(strtok(NULL, " \n"));
 585                                 }
 586                                 buddy[strlen(buddy) - 1] = '\0';
 587                                 dest = g_string_append(dest, buddy);
 588                         } else {
 589                                 dest = g_string_append(dest, buddy);
 590                         }
 591                         dest = g_string_append_c(dest, '\n');
 592                         while ((buddy = g_strchug(strtok(NULL, " \n"))) != NULL) {
 593                                 dest = g_string_append(dest, "b ");
 594                                 if (strchr(buddy, '\"') != NULL) {
 595                                         dest = g_string_append(dest, &buddy[1]);
 596                                         dest = g_string_append_c(dest, ' ');
 597                                         buddy = g_strchug(strtok(NULL, " \n"));
 598                                         while (strchr(buddy, '\"') == NULL) {
 599                                                 dest = g_string_append(dest, buddy);
 600                                                 dest = g_string_append_c(dest, ' ');
 601                                                 buddy = g_strchug(strtok(NULL, " \n"));
 602                                         }
 603                                         buddy[strlen(buddy) - 1] = '\0';
 604                                         dest = g_string_append(dest, buddy);
 605                                 } else {
 606                                         dest = g_string_append(dest, buddy);
 607                                 }
 608                                 dest = g_string_append_c(dest, '\n');
 609                         }
 610                 }
 611         }
 612
 613         return dest;
 614 }
 615
 616 static GString *translate_gnomeicu(FILE *src_fp)
 617 {
 618         char line[BUF_LEN];
 619         GString *dest = g_string_new("m 1\ng Buddies\n");
 620
 621         while (strstr(fgets(line, BUF_LEN, src_fp), "NewContacts") == NULL);
 622
 623         while (fgets(line, BUF_LEN, src_fp)) {
 624                 char *eq;
 625                 g_strchomp(line);
 626                 if (line[0] == '\n' || line[0] == '[')
 627                         break;
 628                 eq = strchr(line, '=');
 629                 if (!eq)
 630                         break;
 631                 *eq = ':';
 632                 eq = strchr(eq, ',');
 633                 if (eq)
 634                         *eq = '\0';
 635                 dest = g_string_append(dest, "b ");
 636                 dest = g_string_append(dest, line);
 637                 dest = g_string_append_c(dest, '\n');
 638         }
 639
 640         return dest;
 641 }
 642
 643 static gchar *get_screenname_filename(const char *name)
 644 {
 645         gchar **split;
 646         gchar *good;
 647
 648         split = g_strsplit(name, G_DIR_SEPARATOR_S, -1);
 649         good = g_strjoinv(NULL, split);
 650         g_strfreev(split);
 651
 652         g_strup(good);
 653
 654         return good;
 655 }
 656
 657 /* see if a buddy list cache file for this user exists */
 658
 659 gboolean bud_list_cache_exists(struct gaim_connection *gc)
 660 {
 661         gboolean ret = FALSE;
 662         char path[PATHSIZE];
 663         char *file;
 664         struct stat sbuf;
 665         char *g_screenname;
 666
 667         g_screenname = get_screenname_filename(gc->username);
 668
 669         file = gaim_user_dir();
 670         if (file != (char *)NULL) {
 671                 g_snprintf(path, sizeof path, "%s/%s.%d.blist", file, g_screenname, gc->protocol);
 672                 if (!stat(path, &sbuf)) {
 673                         debug_printf("%s exists.\n", path);
 674                         ret = TRUE;
 675                 } else {
 676                         char path2[PATHSIZE];
 677                         debug_printf("%s does not exist.\n", path);
 678                         g_snprintf(path2, sizeof path2, "%s/%s.blist", file, g_screenname);
 679                         if (!stat(path2, &sbuf)) {
 680                                 debug_printf("%s exists, moving to %s\n", path2, path);
 681                                 if (rename(path2, path))
 682                                         debug_printf("rename didn't work!\n");
 683                                 else
 684                                         ret = TRUE;
 685                         }
 686                 }
 687                 g_free(file);
 688         }
 689         g_free(g_screenname);
 690         return ret;
 691 }
 692
 693 void do_import(struct gaim_connection *gc, char *filename)
 694 {
 695         GString *buf = NULL;
 696         char first[64];
 697         char path[PATHSIZE];
 698         int len;
 699         FILE *f;
 700         struct stat st;
 701
 702         if (filename) {
 703                 g_snprintf(path, sizeof(path), "%s", filename);
 704         } else {
 705                 char *g_screenname = get_screenname_filename(gc->username);
 706                 char *file = gaim_user_dir();
 707
 708                 if (file != (char *)NULL) {
 709                         sprintf(path, "%s/%s.%d.blist", file, g_screenname, gc->protocol);
 710                         g_free(file);
 711                         g_free(g_screenname);
 712                 } else {
 713                         g_free(g_screenname);
 714                         return;
 715                 }
 716         }
 717
 718         if (stat(path, &st)) {
 719                 debug_printf("Unable to stat %s.\n", path);
 720                 return;
 721         }
 722
 723         if (!(f = fopen(path, "r"))) {
 724                 debug_printf("Unable to open %s.\n", path);
 725                 return;
 726         }
 727
 728         fgets(first, 64, f);
 729
 730         if ((first[0] == '\n') || (first[0] == '\r' && first[1] == '\n'))
 731                 fgets(first, 64, f);
 732
 733         if (!g_strncasecmp(first, "Config {", strlen("Config {"))) {
 734                 /* AIM 4 buddy list */
 735                 debug_printf("aim 4\n");
 736                 rewind(f);
 737                 buf = translate_blt(f);
 738         } else if (strstr(first, "group") != NULL) {
 739                 /* AIM 3 buddy list */
 740                 debug_printf("aim 3\n");
 741                 rewind(f);
 742                 buf = translate_lst(f);
 743         } else if (!g_strncasecmp(first, "[User]", strlen("[User]"))) {
 744                 /* GnomeICU (hopefully) */
 745                 debug_printf("gnomeicu\n");
 746                 rewind(f);
 747                 buf = translate_gnomeicu(f);
 748         } else if (first[0] == 'm') {
 749                 /* Gaim buddy list - no translation */
 750                 char buf2[BUF_LONG * 2];
 751                 buf = g_string_new("");
 752                 rewind(f);
 753                 while (1) {
 754                         len = fread(buf2, 1, BUF_LONG * 2 - 1, f);
 755                         if (len <= 0)
 756                                 break;
 757                         buf2[len] = '\0';
 758                         buf = g_string_append(buf, buf2);
 759                         if (len != BUF_LONG * 2 - 1)
 760                                 break;
 761                 }
 762         }
 763
 764         fclose(f);
 765
 766         if (buf) {
 767                 buf = g_string_prepend(buf, "toc_set_config {");
 768                 buf = g_string_append(buf, "}\n");
 769                 parse_toc_buddy_list(gc, buf->str);
 770                 g_string_free(buf, TRUE);
 771         }
 772 }
 773
 774 void do_export(struct gaim_connection *g)
 775 {
 776         FILE *dir;
 777         FILE *f;
 778         char buf[32 * 1024];
 779         char *file;
 780         char path[PATHSIZE];
 781         char *g_screenname;
 782
 783         file = gaim_user_dir();
 784         if (!file)
 785                 return;
 786
 787         strcpy(buf, file);
 788         dir = fopen(buf, "r");
 789         if (!dir)
 790                 mkdir(buf, S_IRUSR | S_IWUSR | S_IXUSR);
 791         else
 792                 fclose(dir);
 793
 794         g_screenname = get_screenname_filename(g->username);
 795
 796         sprintf(path, "%s/%s.%d.blist", file, g_screenname, g->protocol);
 797         if ((f = fopen(path, "w"))) {
 798                 debug_printf("writing %s\n", path);
 799                 toc_build_config(g, buf, 8192 - 1, TRUE);
 800                 fprintf(f, "%s\n", buf);
 801                 fclose(f);
 802                 chmod(buf, S_IRUSR | S_IWUSR);
 803         } else {
 804                 debug_printf("unable to write %s\n", path);
 805         }
 806
 807         g_free(g_screenname);
 808         g_free(file);
 809 }
 810
 811 static gboolean is_blocked(struct buddy *b)
 812 {
 813         struct gaim_connection *gc = b->gc;
 814
 815         if (gc->permdeny == PERMIT_ALL)
 816                 return FALSE;
 817
 818         if (gc->permdeny == PERMIT_NONE) {
 819                 if (g_strcasecmp(b->name, gc->displayname))
 820                         return TRUE;
 821                 else
 822                         return FALSE;
 823         }
 824
 825         if (gc->permdeny == PERMIT_SOME) {
 826                 char *x = g_strdup(normalize(b->name));
 827                 GSList *s = gc->permit;
 828                 while (s) {
 829                         if (!g_strcasecmp(x, normalize(s->data)))
 830                                 break;
 831                         s = s->next;
 832                 }
 833                 g_free(x);
 834                 if (s)
 835                         return FALSE;
 836                 return TRUE;
 837         }
 838
 839         if (gc->permdeny == DENY_SOME) {
 840                 char *x = g_strdup(normalize(b->name));
 841                 GSList *s = gc->deny;
 842                 while (s) {
 843                         if (!g_strcasecmp(x, normalize(s->data)))
 844                                 break;
 845                         s = s->next;
 846                 }
 847                 g_free(x);
 848                 if (s)
 849                         return TRUE;
 850                 return FALSE;
 851         }
 852
 853         return FALSE;
 854 }
 855
 856 void signoff_blocked(struct gaim_connection *gc)
 857 {
 858         GSList *g = gc->groups;
 859         while (g) {
 860                 GSList *m = ((struct group *)g->data)->members;
 861                 while (m) {
 862                         struct buddy *b = m->data;
 863                         if (is_blocked(b))
 864                                 serv_got_update(gc, b->name, 0, 0, 0, 0, 0, 0);
 865                         m = m->next;
 866                 }
 867                 g = g->next;
 868         }
 869 }