clients/gtk2/main.c

   1 /*
   2  *  Dolda Connect - Modular multiuser Direct Connect-style client
   3  *  Copyright (C) 2004 Fredrik Tolf (fredrik@dolda2000.com)
   4  *
   5  *  This program is free software; you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License as published by
   7  *  the Free Software Foundation; either version 2 of the License, or
   8  *  (at your option) any later version.
   9  *
  10  *  This program is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *  GNU General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License
  16  *  along with this program; if not, write to the Free Software
  17  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18 */
  19
  20 /* This file is a complete and total mess, mostly because of my
  21  * inability to structure GUI programs properly. Looking at it too
  22  * closely may cause ocular hemorrhaging. */
  23
  24 #include <stdlib.h>
  25 #include <stdio.h>
  26 #include <unistd.h>
  27 #include <string.h>
  28 #include <stdarg.h>
  29 #include <gtk/gtk.h>
  30 #include <sys/socket.h>
  31 #include <netinet/in.h>
  32 #include <gdk/gdkkeysyms.h>
  33 #include <doldaconnect/uilib.h>
  34 #include <doldaconnect/uimisc.h>
  35 #include <doldaconnect/utils.h>
  36 #include <errno.h>
  37 #include <regex.h>
  38 #include <signal.h>
  39 #include <time.h>
  40 #include <sys/time.h>
  41 #include <pwd.h>
  42 #include <locale.h>
  43 #include <libintl.h>
  44 #include <assert.h>
  45
  46 /* "Programming with libxml2 is like the thrilling embrace of an
  47  * exotic strangler."
  48  *    --Me */
  49 #include <libxml/parser.h>
  50 #include <libxml/tree.h>
  51
  52 #ifdef HAVE_CONFIG_H
  53 #include <config.h>
  54 #endif
  55 #include "progressbar.h"
  56
  57 #define TRHISTSIZE 10
  58 #define PHO_INIT 0
  59 #define PHO_DATA 1
  60 #define PHO_EOF 2
  61 #define PHO_FINI 3
  62
  63 struct trdata
  64 {
  65     size_t poshist[TRHISTSIZE];
  66     double timehist[TRHISTSIZE];
  67     int hc;
  68 };
  69
  70 struct fndata
  71 {
  72     GtkTextBuffer *textbuf;
  73 };
  74
  75 struct srchsize
  76 {
  77     int size;
  78     int num;
  79     int slots;
  80     double resptime;
  81     GtkTreeRowReference *ref;
  82 };
  83
  84 struct knownspeed
  85 {
  86     char *userid;
  87     int speed, seq;
  88     time_t fetched;
  89 };
  90
  91 GtkWidget *inpdialog;
  92 GtkListStore *fnmodel, *ulmodel, *dlmodel, *reslist;
  93 int (*pubhubhandler)(int, char *, size_t *) = NULL;
  94 GtkTreeStore *srchmodel;
  95 GtkTreeModelFilter *srchmodelfilter;
  96 GtkTextTagTable *chattags;
  97 int dcfd = -1, gdkread = -1, gdkwrite = -1;
  98 int pubhubfd = -1, pubhubtag = -1, filterpubhub = 0;
  99 int curchat = -1;
 100 regex_t pubhubfilter;
 101 pid_t pubhubproc = 0;
 102 char *pubhubaddr = NULL;
 103 char *connectas = NULL;
 104 char *dcserver = NULL;
 105 int autoconn = 1;
 106 int srchautoupdate = 0;
 107 int cursrch = -1, nextsrch = -1;
 108 time_t srcheta;
 109 struct srchsize *srchsizes = NULL;
 110 struct knownspeed *knownspeeds = NULL;
 111 int numsizes = 0, numspeeds = 0, ksqueryseq = -1, ksquerytag = -1, lsrestag = -1;
 112
 113 gboolean initdeath(GtkWidget *, gpointer);
 114 void cb_main_connmenu_activate(GtkWidget *widget, gpointer data);
 115 void cb_main_dconnmenu_activate(GtkWidget *widget, gpointer data);
 116 void cb_main_prefmenu_activate(GtkWidget *widget, gpointer data);
 117 void cb_main_lsres_activate(GtkWidget *widget, gpointer data);
 118 void cb_main_sdmenu_activate(GtkWidget *widget, gpointer data);
 119 void cb_inpdialog_entry_activate(GtkWidget *widget, gpointer data);
 120 void cb_main_fnaddr_activate(GtkWidget *widget, gpointer data);
 121 void cb_main_pubhubfilter_activate(GtkWidget *widget, gpointer data);
 122 void cb_main_dcnctbtn_clicked(GtkWidget *widget, gpointer data);
 123 void cb_main_phublist_cchange(GtkWidget *widget, gpointer data);
 124 void cb_main_phublist_activate(GtkWidget *widget, GtkTreePath *path, GtkTreeViewColumn *col, gpointer data);
 125 void cb_main_chatnodes_activate(GtkWidget *widget, GtkTreePath *path, GtkTreeViewColumn *col, gpointer data);
 126 void cb_main_srchres_activate(GtkWidget *widget, GtkTreePath *path, GtkTreeViewColumn *col, gpointer data);
 127 void cb_main_chatstr_activate(GtkWidget *widget, gpointer data);
 128 void cb_main_simplesrch_changed(GtkWidget *widget, gpointer data);
 129 void cb_main_realsrch_changed(GtkWidget *widget, gpointer data);
 130 void cb_main_srchbtn_clicked(GtkWidget *widget, gpointer data);
 131 void cb_main_srchcanbtn_clicked(GtkWidget *widget, gpointer data);
 132 gboolean cb_main_trlist_keypress(GtkWidget *widget, GdkEventKey *event, gpointer data);
 133 void cb_main_filternoslots_toggled(GtkToggleButton *widget, gpointer data);
 134 void cb_main_srhash_activate(GtkWidget *widget, gpointer data);
 135 void cb_main_srcopy_activate(GtkWidget *widget, gpointer data);
 136 void cb_main_trhash_activate(GtkWidget *widget, gpointer data);
 137 void cb_main_trcopy_activate(GtkWidget *widget, gpointer data);
 138 void cb_main_trreset_activate(GtkWidget *widget, gpointer data);
 139 void cb_main_trcancel_activate(GtkWidget *widget, gpointer data);
 140 gboolean cb_main_srpopup(GtkWidget *widget, GdkEventButton *event, gpointer data);
 141 gboolean cb_main_trpopup(GtkWidget *widget, GdkEventButton *event, gpointer data);
 142 void cb_reslist_reload_clicked(GtkWidget *widget, gpointer data);
 143 void cb_reslist_delete_clicked(GtkWidget *widget, gpointer data);
 144 void cb_reslist_search_clicked(GtkWidget *widget, gpointer data);
 145 void cb_reslist_list_cchange(GtkWidget *widget, gpointer data);
 146 void cb_reslist_list_activate(GtkWidget *widget, GtkTreePath *path, GtkTreeViewColumn *col, gpointer data);
 147 gboolean cb_reslist_list_keypress(GtkWidget *widget, GdkEventKey *event, gpointer data);
 148 void dcfdcallback(gpointer data, gint source, GdkInputCondition condition);
 149 void srchstatupdate(void);
 150 void transnicebytefunc(GtkTreeViewColumn *col, GtkCellRenderer *rend, GtkTreeModel *model, GtkTreeIter *iter, gpointer data);
 151 void transnicebytefunc2(GtkTreeViewColumn *col, GtkCellRenderer *rend, GtkTreeModel *model, GtkTreeIter *iter, gpointer data);
 152 void transspeedinfo(GtkTreeViewColumn *col, GtkCellRenderer *rend, GtkTreeModel *model, GtkTreeIter *iter, gpointer data);
 153 void transerrorinfo(GtkTreeViewColumn *col, GtkCellRenderer *rend, GtkTreeModel *model, GtkTreeIter *iter, gpointer data);
 154 void percentagefunc(GtkTreeViewColumn *col, GtkCellRenderer *rend, GtkTreeModel *model, GtkTreeIter *iter, gpointer data);
 155 void hidezerofunc(GtkTreeViewColumn *col, GtkCellRenderer *rend, GtkTreeModel *model, GtkTreeIter *iter, gpointer data);
 156 void speedtimefunc(GtkTreeViewColumn *col, GtkCellRenderer *rend, GtkTreeModel *model, GtkTreeIter *iter, gpointer data);
 157
 158 #define DCCHARSET "windows-1252"
 159
 160 #define _(text) gettext(text)
 161
 162 #include "mainwnd.gtk"
 163 #include "inpdialog.gtk"
 164 #include "pref.gtk"
 165 #include "reslist.gtk"
 166
 167 void updatewrite(void)
 168 {
 169     if(dcfd < 0)
 170         return;
 171     if(dc_wantwrite())
 172     {
 173         if(gdkwrite == -1)
 174             gdkwrite = gdk_input_add(dcfd, GDK_INPUT_WRITE, dcfdcallback, NULL);
 175     } else {
 176         if(gdkwrite != -1)
 177         {
 178             gdk_input_remove(gdkwrite);
 179             gdkwrite = -1;
 180         }
 181     }
 182 }
 183
 184 double ntime(void)
 185 {
 186     struct timeval tv;
 187
 188     gettimeofday(&tv, NULL);
 189     return((double)tv.tv_sec + ((double)tv.tv_usec / 1000000.0));
 190 }
 191
 192 void fndestroycb(struct dc_fnetnode *fn)
 193 {
 194     struct fndata *data;
 195     GtkTextBuffer *textbuf;
 196
 197     data = fn->udata;
 198     g_object_unref(data->textbuf);
 199     free(data);
 200     if(curchat == fn->id)
 201     {
 202         textbuf = gtk_text_buffer_new(chattags);
 203         gtk_text_view_set_buffer(GTK_TEXT_VIEW(main_chatview), textbuf);
 204         g_object_unref(textbuf);
 205     }
 206 }
 207
 208 void addfndata(struct dc_fnetnode *fn)
 209 {
 210     struct fndata *data;
 211
 212     if(fn->udata != NULL)
 213         return;
 214     fn->destroycb = fndestroycb;
 215     data = smalloc(sizeof(*data));
 216     data->textbuf = gtk_text_buffer_new(chattags);
 217     fn->udata = data;
 218 }
 219
 220 void trdestroycb(struct dc_transfer *tr)
 221 {
 222     free(tr->udata);
 223 }
 224
 225 void addtrdata(struct dc_transfer *tr)
 226 {
 227     struct trdata *data;
 228
 229     if(tr->udata != NULL)
 230         return;
 231     tr->destroycb = trdestroycb;
 232     data = smalloc(sizeof(*data));
 233     memset(data, 0, sizeof(*data));
 234     tr->udata = data;
 235 }
 236
 237 void updatetrdata(struct dc_transfer *tr)
 238 {
 239     int i;
 240     struct trdata *data;
 241
 242     data = tr->udata;
 243     if(data->hc < TRHISTSIZE)
 244     {
 245         data->poshist[data->hc] = tr->curpos;
 246         data->timehist[data->hc] = ntime();
 247         data->hc++;
 248     } else {
 249         for(i = 0; i < TRHISTSIZE - 1; i++)
 250         {
 251             data->poshist[i] = data->poshist[i + 1];
 252             data->timehist[i] = data->timehist[i + 1];
 253         }
 254         data->poshist[i] = tr->curpos;
 255         data->timehist[i] = ntime();
 256     }
 257 }
 258
 259 char *getfnstatestock(int state)
 260 {
 261     if(state == DC_FNN_STATE_SYN)
 262         return("gtk-jump-to");
 263     if(state == DC_FNN_STATE_HS)
 264         return("gtk-execute");
 265     if(state == DC_FNN_STATE_EST)
 266         return("gtk-yes");
 267     if(state == DC_FNN_STATE_DEAD)
 268         return("gtk-cancel");
 269     return(NULL);
 270 }
 271
 272 void updatehublist(void)
 273 {
 274     int done;
 275     struct dc_fnetnode *fn;
 276     GtkTreeIter iter;
 277     int id;
 278     char *buf;
 279     char *name;
 280     int state, numusers;
 281
 282     for(fn = dc_fnetnodes; fn != NULL; fn = fn->next)
 283         fn->found = 0;
 284     done = 0;
 285     while(!done)
 286     {
 287         done = 1;
 288         if(gtk_tree_model_get_iter_first(GTK_TREE_MODEL(fnmodel), &iter))
 289         {
 290             do
 291             {
 292                 gtk_tree_model_get(GTK_TREE_MODEL(fnmodel), &iter, 0, &id, -1);
 293                 if((fn = dc_findfnetnode(id)) == NULL)
 294                 {
 295                     /* I can't seem to get a sensible reply fromp
 296                      * gtk_list_store, so I'm just doing this
 297                      * instead. */
 298                     gtk_list_store_remove(fnmodel, &iter);
 299                     done = 0;
 300                     break;
 301                 } else {
 302                     gtk_tree_model_get(GTK_TREE_MODEL(fnmodel), &iter, 1, &name, 2, &state, 3, &numusers, -1);
 303                     if(fn->name == NULL)
 304                         buf = _("Unknown");
 305                     else
 306                         buf = icswcstombs(fn->name, "UTF-8", NULL);
 307                     if(strcmp(buf, name))
 308                         gtk_list_store_set(fnmodel, &iter, 1, buf, -1);
 309                     if(state != fn->state)
 310                     {
 311                         gtk_list_store_set(fnmodel, &iter, 2, fn->state, -1);
 312                         gtk_list_store_set(fnmodel, &iter, 4, getfnstatestock(fn->state), -1);
 313                     }
 314                     if(numusers != fn->numusers)
 315                         gtk_list_store_set(fnmodel, &iter, 3, fn->numusers, -1);
 316                     g_free(name);
 317                     fn->found = 1;
 318                 }
 319             } while(gtk_tree_model_iter_next(GTK_TREE_MODEL(fnmodel), &iter));
 320         }
 321     }
 322     for(fn = dc_fnetnodes; fn != NULL; fn = fn->next)
 323     {
 324         if(!fn->found)
 325         {
 326             if(fn->name == NULL)
 327                 buf = _("Unknown");
 328             else
 329                 buf = icswcstombs(fn->name, "UTF-8", NULL);
 330             gtk_list_store_append(fnmodel, &iter);
 331             gtk_list_store_set(fnmodel, &iter, 0, fn->id, 1, buf, 2, fn->state, 3, fn->numusers, 4, getfnstatestock(fn->state), -1);
 332             addfndata(fn);
 333         }
 334     }
 335 }
 336
 337 char *bytes2si(long long bytes)
 338 {
 339     int i;
 340     double b;
 341     char *sd;
 342     static char ret[64];
 343
 344     b = bytes;
 345     for(i = 0; (b >= 1024) && (i < 4); i++)
 346         b /= 1024;
 347     if(i == 0)
 348         sd = "B";
 349     else if(i == 1)
 350         sd = "kiB";
 351     else if(i == 2)
 352         sd = "MiB";
 353     else if(i == 3)
 354         sd = "GiB";
 355     else
 356         sd = "TiB";
 357     snprintf(ret, 64, "%.1f %s", b, sd);
 358     return(ret);
 359 }
 360
 361 void percentagefunc(GtkTreeViewColumn *col, GtkCellRenderer *rend, GtkTreeModel *model, GtkTreeIter *iter, gpointer data)
 362 {
 363     int colnum;
 364     float val;
 365     char buf[64];
 366
 367     colnum = GPOINTER_TO_INT(data);
 368     gtk_tree_model_get(model, iter, colnum, &val, -1);
 369     snprintf(buf, 64, "%.2f%%", (double)(val * 100.0));
 370     g_object_set(rend, "text", buf, NULL);
 371 }
 372
 373 void transnicebytefunc(GtkTreeViewColumn *col, GtkCellRenderer *rend, GtkTreeModel *model, GtkTreeIter *iter, gpointer data)
 374 {
 375     int colnum, val;
 376     char buf[64];
 377
 378     colnum = GPOINTER_TO_INT(data);
 379     gtk_tree_model_get(model, iter, colnum, &val, -1);
 380     if(val >= 0)
 381         snprintf(buf, 64, "%'i", val);
 382     else
 383         strcpy(buf, _("Unknown"));
 384     g_object_set(rend, "text", buf, NULL);
 385 }
 386
 387 void transnicebytefunc2(GtkTreeViewColumn *col, GtkCellRenderer *rend, GtkTreeModel *model, GtkTreeIter *iter, gpointer data)
 388 {
 389     int colnum;
 390     long long val;
 391     char buf[64];
 392
 393     colnum = GPOINTER_TO_INT(data);
 394     gtk_tree_model_get(model, iter, colnum, &val, -1);
 395     if(val >= 0)
 396         strcpy(buf, bytes2si(val));
 397     else
 398         strcpy(buf, _("Unknown"));
 399     g_object_set(rend, "text", buf, NULL);
 400 }
 401
 402 void hidezerofunc(GtkTreeViewColumn *col, GtkCellRenderer *rend, GtkTreeModel *model, GtkTreeIter *iter, gpointer data)
 403 {
 404     int colnum, val;
 405     char buf[64];
 406
 407     colnum = GPOINTER_TO_INT(data);
 408     gtk_tree_model_get(model, iter, colnum, &val, -1);
 409     if(val > 0)
 410         snprintf(buf, 64, "%i", val);
 411     else
 412         strcpy(buf, "");
 413     g_object_set(rend, "text", buf, NULL);
 414 }
 415
 416 void speedtimefunc(GtkTreeViewColumn *col, GtkCellRenderer *rend, GtkTreeModel *model, GtkTreeIter *iter, gpointer data)
 417 {
 418     int speed, size, time;
 419     char buf[64];
 420
 421     gtk_tree_model_get(model, iter, 4, &size, 8, &speed, -1);
 422     if(speed > 0)
 423     {
 424         time = (size / speed) / 60;
 425         if(time < 1)
 426             snprintf(buf, 64, "%'i (<00:01)", speed);
 427         else
 428             snprintf(buf, 64, "%'i (%02i:%02i)", speed, time / 60, time % 60);
 429     } else if(speed == 0) {
 430         strcpy(buf, "0");
 431     } else {
 432         strcpy(buf, _("Unknown"));
 433     }
 434     g_object_set(rend, "text", buf, NULL);
 435 }
 436
 437 void transspeedinfo(GtkTreeViewColumn *col, GtkCellRenderer *rend, GtkTreeModel *model, GtkTreeIter *iter, gpointer data)
 438 {
 439     int id;
 440     struct dc_transfer *tr;
 441     struct trdata *d;
 442     char buf[64];
 443     int speed;
 444
 445     gtk_tree_model_get(model, iter, 0, &id, -1);
 446     if((tr = dc_findtransfer(id)) != NULL)
 447     {
 448         d = tr->udata;
 449         if((tr->state != DC_TRNS_MAIN) || (d == NULL))
 450         {
 451             buf[0] = 0;
 452         } else if(d->hc < 2) {
 453             strcpy(buf, "...");
 454         } else {
 455             speed = (((double)(d->poshist[d->hc - 1] - d->poshist[0])) / (d->timehist[d->hc - 1] - d->timehist[0]));
 456             snprintf(buf, 64, "%s/s", bytes2si(speed));
 457         }
 458     } else {
 459         buf[0] = 0;
 460     }
 461     g_object_set(rend, "text", buf, NULL);
 462 }
 463
 464 void transerrorinfo(GtkTreeViewColumn *col, GtkCellRenderer *rend, GtkTreeModel *model, GtkTreeIter *iter, gpointer data)
 465 {
 466     int error;
 467     time_t errortime;
 468     char finbuf[64], tbuf[64], *errstr;
 469
 470     gtk_tree_model_get(model, iter, 10, &error, 11, &errortime, -1);
 471     if(error != DC_TRNSE_NOERROR)
 472     {
 473         if(error == DC_TRNSE_NOTFOUND)
 474             errstr = _("Not found");
 475         else if(error == DC_TRNSE_NOSLOTS)
 476             errstr = _("No slots");
 477         strftime(tbuf, 64, _("%H:%M:%S"), localtime(&errortime));
 478         snprintf(finbuf, 64, _("%s (reported at %s)"), errstr, tbuf);
 479     } else {
 480         *finbuf = 0;
 481     }
 482     g_object_set(rend, "text", finbuf, NULL);
 483 }
 484
 485 char *gettrstatestock(int state)
 486 {
 487     if(state == DC_TRNS_WAITING)
 488         return("gtk-jump-to");
 489     if(state == DC_TRNS_HS)
 490         return("gtk-execute");
 491     if(state == DC_TRNS_MAIN)
 492         return("gtk-network");
 493     if(state == DC_TRNS_DONE)
 494         return("gtk-yes");
 495     return(NULL);
 496 }
 497
 498 gint updatetransfers(gpointer data)
 499 {
 500     struct dc_transfer *tr;
 501     struct trdata *d;
 502     double now;
 503
 504     now = ntime();
 505     for(tr = dc_transfers; tr != NULL; tr = tr->next)
 506     {
 507         if((d = tr->udata) != NULL)
 508         {
 509             if((d->hc > 0) && ((now - d->timehist[d->hc - 1]) > 2))
 510                 updatetrdata(tr);
 511         }
 512     }
 513     return(TRUE);
 514 }
 515
 516 void updatetransferlists(void)
 517 {
 518     int i;
 519     int done;
 520     struct dc_transfer *transfer;
 521     GtkTreeIter iter;
 522     int id;
 523     char *buf;
 524     char *peerid, *peernick, *path, *hash;
 525     int state, dir, size, curpos, error;
 526     time_t errortime;
 527     GtkListStore *stores[3];
 528
 529     for(transfer = dc_transfers; transfer != NULL; transfer = transfer->next)
 530         transfer->found = 0;
 531     stores[DC_TRNSD_UNKNOWN] = NULL;
 532     stores[DC_TRNSD_UP] = ulmodel;
 533     stores[DC_TRNSD_DOWN] = dlmodel;
 534     for(i = 0; i < 3; i++)
 535     {
 536         if(stores[i] == NULL)
 537             continue;
 538         done = 0;
 539         while(!done)
 540         {
 541             done = 1;
 542             if(gtk_tree_model_get_iter_first(GTK_TREE_MODEL(stores[i]), &iter))
 543             {
 544                 do
 545                 {
 546                     gtk_tree_model_get(GTK_TREE_MODEL(stores[i]), &iter, 0, &id, 1, &dir, -1);
 547                     if(((transfer = dc_findtransfer(id)) == NULL) || (transfer->dir != dir))
 548                     {
 549                         gtk_list_store_remove(stores[i], &iter);
 550                         done = 0;
 551                         break;
 552                     } else {
 553                         transfer->found = 1;
 554                         gtk_tree_model_get(GTK_TREE_MODEL(stores[i]), &iter, 2, &state, 3, &peerid, 4, &peernick, 5, &path, 6, &size, 7, &curpos, 10, &error, 11, &errortime, 12, &hash, -1);
 555                         if(state != transfer->state)
 556                             gtk_list_store_set(stores[i], &iter, 2, transfer->state, 8, gettrstatestock(transfer->state), -1);
 557                         if(size != transfer->size)
 558                             gtk_list_store_set(stores[i], &iter, 6, transfer->size, -1);
 559                         if(curpos != transfer->curpos)
 560                         {
 561                             gtk_list_store_set(stores[i], &iter, 7, transfer->curpos, -1);
 562                             if(transfer->udata != NULL)
 563                                 updatetrdata(transfer);
 564                         }
 565                         if(error != transfer->error)
 566                             gtk_list_store_set(stores[i], &iter, 10, transfer->error, -1);
 567                         if(errortime != transfer->errortime)
 568                             gtk_list_store_set(stores[i], &iter, 11, transfer->errortime, -1);
 569                         if((transfer->size > 0) && (transfer->curpos > 0))
 570                             gtk_list_store_set(stores[i], &iter, 9, (float)transfer->curpos / (float)transfer->size, -1);
 571                         buf = icswcstombs(transfer->peerid, "UTF-8", NULL);
 572                         if(strcmp(buf, peerid))
 573                             gtk_list_store_set(stores[i], &iter, 3, buf, -1);
 574                         buf = icswcstombs(((transfer->peernick == NULL) || (transfer->peernick[0] == L'\0'))?transfer->peerid:transfer->peernick, "UTF-8", NULL);
 575                         if(strcmp(buf, peernick))
 576                             gtk_list_store_set(stores[i], &iter, 4, buf, -1);
 577                         buf = (transfer->path == NULL)?_("Unknown"):icswcstombs(transfer->path, "UTF-8", NULL);
 578                         if(strcmp(buf, path))
 579                             gtk_list_store_set(stores[i], &iter, 5, buf, -1);
 580                         buf = (transfer->hash == NULL)?"":icswcstombs(transfer->hash, "UTF-8", NULL);
 581                         if(strcmp(buf, path))
 582                             gtk_list_store_set(stores[i], &iter, 12, buf, -1);
 583                         g_free(hash);
 584                         g_free(peerid);
 585                         g_free(peernick);
 586                         g_free(path);
 587                     }
 588                 } while(gtk_tree_model_iter_next(GTK_TREE_MODEL(stores[i]), &iter));
 589             }
 590         }
 591     }
 592     for(transfer = dc_transfers; transfer != NULL; transfer = transfer->next)
 593     {
 594         if(!transfer->found)
 595         {
 596             if(stores[transfer->dir] != NULL)
 597             {
 598                 peerid = icwcstombs(transfer->peerid, "UTF-8");
 599                 peernick = icwcstombs(((transfer->peernick == NULL) || (transfer->peernick[0] == L'\0'))?transfer->peerid:transfer->peernick, "UTF-8");
 600                 path = (transfer->path == NULL)?_("Unknown"):icwcstombs(transfer->path, "UTF-8");
 601                 hash = (transfer->hash == NULL)?"":icwcstombs(transfer->hash, "UTF-8");
 602                 gtk_list_store_append(stores[transfer->dir], &iter);
 603                 gtk_list_store_set(stores[transfer->dir], &iter,
 604                                    0, transfer->id,
 605                                    1, transfer->dir,
 606                                    2, transfer->state,
 607                                    3, peerid,
 608                                    4, peernick,
 609                                    5, path,
 610                                    6, transfer->size,
 611                                    7, transfer->curpos,
 612                                    8, gettrstatestock(transfer->state),
 613                                    9, 0.0,
 614                                    10, transfer->error,
 615                                    11, transfer->errortime,
 616                                    12, hash,
 617                                    -1);
 618                 free(peerid);
 619                 free(peernick);
 620                 if(transfer->path != NULL)
 621                     free(path);
 622                 if(transfer->hash != NULL)
 623                     free(hash);
 624                 addtrdata(transfer);
 625             }
 626         }
 627     }
 628 }
 629
 630 void updatesbar(char *msg)
 631 {
 632     gtk_statusbar_pop(GTK_STATUSBAR(main_statusbar), 0);
 633     gtk_statusbar_push(GTK_STATUSBAR(main_statusbar), 0, msg);
 634 }
 635
 636 void freesrchsizes(void)
 637 {
 638     int i;
 639
 640     for(i = 0; i < numsizes; i++)
 641     {
 642         if(srchsizes[i].ref != NULL)
 643             gtk_tree_row_reference_free(srchsizes[i].ref);
 644     }
 645     if(srchsizes != NULL)
 646         free(srchsizes);
 647     srchsizes = NULL;
 648     numsizes = 0;
 649 }
 650
 651 void dcdisconnected(void)
 652 {
 653     if(gdkread != -1)
 654     {
 655         gdk_input_remove(gdkread);
 656         gdkread = -1;
 657     }
 658     dcfd = -1;
 659     updatehublist();
 660     updatetransferlists();
 661     cursrch = nextsrch = -1;
 662     gtk_tree_store_clear(srchmodel);
 663     freesrchsizes();
 664     gtk_widget_set_sensitive(main_connmenu, TRUE);
 665     gtk_widget_set_sensitive(main_dconnmenu, FALSE);
 666     gtk_widget_set_sensitive(main_simplesrch, TRUE);
 667     gtk_widget_set_sensitive(main_realsrch, TRUE);
 668     gtk_widget_set_sensitive(main_srchbtn, TRUE);
 669     gtk_widget_set_sensitive(main_srchcanbtn, FALSE);
 670     updatesbar(_("Disconnected"));
 671 }
 672
 673 char *inputbox(char *title, char *prompt, char *def, int echo)
 674 {
 675     int resp;
 676     GtkWidget *swnd;
 677     char *buf;
 678
 679     inpdialog = gtk_dialog_new_with_buttons(title, GTK_WINDOW(main_wnd), GTK_DIALOG_MODAL, GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, NULL);
 680     gtk_box_pack_start(GTK_BOX(GTK_DIALOG(inpdialog)->vbox), swnd = create_inpdialog_wnd(), TRUE, TRUE, 0);
 681     gtk_widget_show(swnd);
 682     if(!echo)
 683         gtk_entry_set_visibility(GTK_ENTRY(inpdialog_entry), FALSE);
 684     gtk_label_set_text(GTK_LABEL(inpdialog_prompt), prompt);
 685     gtk_entry_set_text(GTK_ENTRY(inpdialog_entry), def);
 686     resp = gtk_dialog_run(GTK_DIALOG(inpdialog));
 687     if(!echo)
 688         gtk_entry_set_visibility(GTK_ENTRY(inpdialog_entry), TRUE);
 689     if(resp == GTK_RESPONSE_ACCEPT)
 690         buf = strdup(gtk_entry_get_text(GTK_ENTRY(inpdialog_entry)));
 691     else
 692         buf = NULL;
 693     gtk_widget_destroy(inpdialog);
 694     updatewrite();
 695     return(buf);
 696 }
 697
 698 int msgbox(int type, int buttons, char *format, ...)
 699 #if defined(__GNUC__)
 700     __attribute__ ((format (printf, 3, 4)))
 701 #endif
 702 ;
 703
 704 int msgbox(int type, int buttons, char *format, ...)
 705 {
 706     GtkWidget *swnd;
 707     va_list args;
 708     char *buf;
 709     int resp;
 710
 711     va_start(args, format);
 712     buf = vsprintf2(format, args);
 713     va_end(args);
 714     swnd = gtk_message_dialog_new(GTK_WINDOW(main_wnd), GTK_DIALOG_MODAL, type, buttons, "%s", buf);
 715     resp = gtk_dialog_run(GTK_DIALOG(swnd));
 716     gtk_widget_destroy(swnd);
 717     free(buf);
 718     return(resp);
 719 }
 720
 721 void readconfigfile(void)
 722 {
 723     FILE *cfgfile;
 724     char *homedir, *buf, *p;
 725     int w, h;
 726
 727     if((homedir = getenv("HOME")) == NULL)
 728     {
 729         fprintf(stderr, "warning: could not find home directory!\n");
 730         return;
 731     }
 732     buf = sprintf2("%s/.dolconrc", homedir);
 733     if((cfgfile = fopen(buf, "r")) == NULL)
 734     {
 735         if(errno != ENOENT)
 736             perror(buf);
 737         free(buf);
 738         return;
 739     }
 740     free(buf);
 741     buf = smalloc(1024);
 742     while(fgets(buf, 1024, cfgfile) != NULL)
 743     {
 744         if(strlen(buf) < 1)
 745             continue;
 746         p = buf + strlen(buf);
 747         if(p[-1] == '\n')
 748             *(--p) = 0;
 749         if((p = strchr(buf, ':')) == NULL)
 750             continue;
 751         *(p++) = 0;
 752         while((*p == ' ') || (*p == '\t'))
 753             p++;
 754         if(!strcmp(buf, "wnd-width"))
 755         {
 756             w = atoi(p);
 757         } else if(!strcmp(buf, "wnd-height")) {
 758             h = atoi(p);
 759         } else if(!strcmp(buf, "pane1-pos")) {
 760             gtk_paned_set_position(GTK_PANED(main_pane1), atoi(p));
 761         } else if(!strcmp(buf, "pane2-pos")) {
 762             gtk_paned_set_position(GTK_PANED(main_pane2), atoi(p));
 763         } else if(!strcmp(buf, "pane3-pos")) {
 764             gtk_paned_set_position(GTK_PANED(main_pane3), atoi(p));
 765         } else if(!strcmp(buf, "pubhubaddr")) {
 766             free(pubhubaddr);
 767             pubhubaddr = sstrdup(p);
 768         } else if(!strcmp(buf, "dcserver")) {
 769             free(dcserver);
 770             dcserver = sstrdup(p);
 771         } else if(!strcmp(buf, "advexpanded")) {
 772             gtk_expander_set_expanded(GTK_EXPANDER(main_advexp), atoi(p));
 773         } else if(!strcmp(buf, "connectas")) {
 774             free(connectas);
 775             connectas = sstrdup(p);
 776         } else if(!strcmp(buf, "autoconn")) {
 777             autoconn = atoi(p);
 778         } else if(!strcmp(buf, "filternoslots")) {
 779             gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(main_filternoslots), atoi(p));
 780         }
 781     }
 782     free(buf);
 783     fclose(cfgfile);
 784 /*
 785     if(w != 1589)
 786         abort();
 787 */
 788     gtk_window_resize(GTK_WINDOW(main_wnd), w, h);
 789 }
 790
 791 void updateconfigfile(void)
 792 {
 793     FILE *cfgfile;
 794     char *homedir, *buf;
 795     int w, h;
 796
 797     if((homedir = getenv("HOME")) == NULL)
 798     {
 799         msgbox(GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, _("Could not get your home directory!"));
 800         return;
 801     }
 802     buf = sprintf2("%s/.dolconrc", homedir);
 803     if((cfgfile = fopen(buf, "w")) == NULL)
 804     {
 805         free(buf);
 806         msgbox(GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, _("Could not open configuration file for writing: %s"), strerror(errno));
 807         return;
 808     }
 809     free(buf);
 810     gtk_window_get_size(GTK_WINDOW(main_wnd), &w, &h);
 811     fprintf(cfgfile, "wnd-width: %i\n", w);
 812     fprintf(cfgfile, "wnd-height: %i\n", h);
 813     fprintf(cfgfile, "pane1-pos: %i\n", gtk_paned_get_position(GTK_PANED(main_pane1)));
 814     fprintf(cfgfile, "pane2-pos: %i\n", gtk_paned_get_position(GTK_PANED(main_pane2)));
 815     fprintf(cfgfile, "pane3-pos: %i\n", gtk_paned_get_position(GTK_PANED(main_pane3)));
 816     fprintf(cfgfile, "pubhubaddr: %s\n", pubhubaddr);
 817     fprintf(cfgfile, "dcserver: %s\n", dcserver);
 818     fprintf(cfgfile, "advexpanded: %i\n", gtk_expander_get_expanded(GTK_EXPANDER(main_advexp)));
 819     fprintf(cfgfile, "connectas: %s\n", connectas);
 820     fprintf(cfgfile, "autoconn: %i\n", autoconn);
 821     fprintf(cfgfile, "filternoslots: %i\n", gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(main_filternoslots)));
 822     fclose(cfgfile);
 823 }
 824
 825 gboolean initdeath(GtkWidget *widget, gpointer data)
 826 {
 827     updateconfigfile();
 828     gtk_main_quit();
 829     return(TRUE);
 830 }
 831
 832 void cb_inpdialog_entry_activate(GtkWidget *widget, gpointer data)
 833 {
 834     gtk_dialog_response(GTK_DIALOG(inpdialog), GTK_RESPONSE_ACCEPT);
 835 }
 836
 837 int loginconv(int type, wchar_t *prompt, char **resp, void *data)
 838 {
 839     int ret;
 840     char *buf;
 841
 842     ret = 0;
 843     buf = icwcstombs(prompt, "UTF-8");
 844     switch(type)
 845     {
 846     case DC_LOGIN_CONV_NOECHO:
 847         if((*resp = inputbox(_("Login"), buf, "", 0)) == NULL)
 848             ret = 1;
 849         break;
 850     case DC_LOGIN_CONV_ECHO:
 851         if((*resp = inputbox(_("Login"), buf, "", 1)) == NULL)
 852             ret = 1;
 853         break;
 854     case DC_LOGIN_CONV_INFO:
 855         msgbox(GTK_MESSAGE_INFO, GTK_BUTTONS_OK, "%s", buf);
 856         break;
 857     case DC_LOGIN_CONV_ERROR:
 858         msgbox(GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "%s", buf);
 859         break;
 860     }
 861     free(buf);
 862     updatewrite();
 863     return(ret);
 864 }
 865
 866 void getfnlistcallback(int resp, void *data)
 867 {
 868     updatehublist();
 869 }
 870
 871 void gettrlistcallback(int resp, void *data)
 872 {
 873     updatetransferlists();
 874 }
 875
 876 void logincallback(int err, wchar_t *reason, void *data)
 877 {
 878     switch(err)
 879     {
 880     case DC_LOGIN_ERR_SUCCESS:
 881         dc_queuecmd(NULL, NULL, L"notify", L"all", L"on", NULL);
 882         dc_getfnlistasync(getfnlistcallback, NULL);
 883         dc_gettrlistasync(gettrlistcallback, NULL);
 884         updatesbar("Authenticated");
 885         break;
 886     case DC_LOGIN_ERR_NOLOGIN:
 887         msgbox(GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, _("Could not negotiate an acceptable authentication mechanism"));
 888         dc_disconnect();
 889         dcdisconnected();
 890         break;
 891     case DC_LOGIN_ERR_SERVER:
 892         msgbox(GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, _("The server has encountered an error"));
 893         dc_disconnect();
 894         dcdisconnected();
 895         break;
 896     case DC_LOGIN_ERR_USER:
 897         msgbox(GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, _("Internal client error"));
 898         dc_disconnect();
 899         dcdisconnected();
 900         break;
 901     case DC_LOGIN_ERR_CONV:
 902         dc_disconnect();
 903         dcdisconnected();
 904         break;
 905     case DC_LOGIN_ERR_AUTHFAIL:
 906         msgbox(GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, _("Login attempt failed!"));
 907         dc_disconnect();
 908         dcdisconnected();
 909         break;
 910     }
 911     updatewrite();
 912 }
 913
 914 GtkTreeIter *ref2iter(GtkTreeRowReference *ref)
 915 {
 916     static GtkTreeIter iter;
 917     GtkTreePath *path;
 918
 919     assert((path = gtk_tree_row_reference_get_path(ref)) != NULL);
 920     assert(gtk_tree_model_get_iter(GTK_TREE_MODEL(srchmodel), &iter, path));
 921     gtk_tree_path_free(path);
 922     return(&iter);
 923 }
 924
 925 GtkTreeRowReference *iter2ref(GtkTreeIter *iter)
 926 {
 927     GtkTreePath *path;
 928     GtkTreeRowReference *ref;
 929
 930     assert((path = gtk_tree_model_get_path(GTK_TREE_MODEL(srchmodel), iter)) != NULL);
 931     assert((ref = gtk_tree_row_reference_new(GTK_TREE_MODEL(srchmodel), path)) != NULL);
 932     gtk_tree_path_free(path);
 933     return(ref);
 934 }
 935
 936 struct srchsize *finddiscsize(void)
 937 {
 938     int i;
 939     GtkTreeIter iter;
 940
 941     for(i = 0; i < numsizes; i++)
 942     {
 943         if(srchsizes[i].size == -1)
 944             return(&srchsizes[i]);
 945     }
 946     srchsizes = srealloc(srchsizes, sizeof(*srchsizes) * ++numsizes);
 947     srchsizes[i].size = -1;
 948     srchsizes[i].num = 1;
 949     srchsizes[i].slots = 0;
 950     srchsizes[i].resptime = 0.0;
 951     gtk_tree_store_append(srchmodel, &iter, NULL);
 952     gtk_tree_store_set(srchmodel, &iter, 3, _("Discrete sizes"), 7, 1, -1);
 953     srchsizes[i].ref = iter2ref(&iter);
 954     return(&srchsizes[i]);
 955 }
 956
 957 struct knownspeed *findksentbyname(char *userid)
 958 {
 959     int i;
 960
 961     for(i = 0; i < numspeeds; i++)
 962     {
 963         if(!strcmp(knownspeeds[i].userid, userid))
 964             return(&knownspeeds[i]);
 965     }
 966     return(NULL);
 967 }
 968
 969 struct knownspeed *findksentbyseq(int seq)
 970 {
 971     int i;
 972
 973     for(i = 0; i < numspeeds; i++)
 974     {
 975         if(knownspeeds[i].seq == seq)
 976             return(&knownspeeds[i]);
 977     }
 978     return(NULL);
 979 }
 980
 981 gboolean ksupdaterow(GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer data)
 982 {
 983     struct knownspeed *ks;
 984     char *userid;
 985
 986     gtk_tree_model_get(GTK_TREE_MODEL(model), iter, 1, &userid, -1);
 987     if(userid == NULL)
 988         return(FALSE);
 989     ks = findksentbyname(userid);
 990     if(ks == NULL)
 991     {
 992         knownspeeds = srealloc(knownspeeds, (numspeeds + 1) * sizeof(*knownspeeds));
 993         ks = &knownspeeds[numspeeds];
 994         numspeeds++;
 995         ks->userid = sstrdup(userid);
 996         ks->speed = -1;
 997         ks->seq = -2;
 998         ksqueryseq = -2;
 999     }
1000     g_free(userid);
1001     if(ks->speed != -1)
1002         gtk_tree_store_set(GTK_TREE_STORE(model), iter, 8, ks->speed, -1);
1003     return(FALSE);
1004 }
1005
1006 gint ksupdatecb(gpointer data)
1007 {
1008     int i, oldnum;
1009     time_t now;
1010     wchar_t **users, *buf;
1011     size_t userssize, usersdata;
1012
1013     if(ksquerytag != -1)
1014         return(TRUE);
1015     now = time(NULL);
1016     oldnum = numspeeds;
1017     for(i = 0; i < numspeeds;)
1018     {
1019         if(now - knownspeeds[i].fetched > 60)
1020         {
1021             free(knownspeeds[i].userid);
1022             memmove(&knownspeeds[i], &knownspeeds[i + 1], (--numspeeds - i) * sizeof(*knownspeeds));
1023         } else {
1024             i++;
1025         }
1026     }
1027     if(oldnum != numspeeds)
1028     {
1029         if(numspeeds == 0)
1030         {
1031             free(knownspeeds);
1032             knownspeeds = NULL;
1033         } else {
1034             knownspeeds = srealloc(knownspeeds, numspeeds * sizeof(*knownspeeds));
1035         }
1036     }
1037     gtk_tree_model_foreach(GTK_TREE_MODEL(srchmodel), ksupdaterow, NULL);
1038     if(ksqueryseq == -2)
1039     {
1040         users = NULL;
1041         userssize = usersdata = 0;
1042         ksqueryseq = 0;
1043         for(i = 0; i < numspeeds; i++)
1044         {
1045             if(knownspeeds[i].seq == -2)
1046             {
1047                 assert((buf = icmbstowcs(knownspeeds[i].userid, "UTF-8")) != NULL);
1048                 knownspeeds[i].seq = ksqueryseq++;
1049                 addtobuf(users, buf);
1050             }
1051         }
1052         addtobuf(users, NULL);
1053         ksquerytag = dc_queuecmd(NULL, NULL, L"filtercmd", L"userspeeda", L"%a", users, NULL);
1054         dc_freewcsarr(users);
1055     }
1056     return(TRUE);
1057 }
1058
1059 void handleresps(void)
1060 {
1061     int i;
1062     struct dc_response *resp;
1063     struct dc_intresp *ires;
1064     struct dc_fnetnode *fn;
1065     struct fndata *fndata;
1066     GtkTextIter iter;
1067     GtkTreeIter titer, piter;
1068     char *buf, *p;
1069     int tosbuf;
1070     struct srchsize *ss;
1071     struct knownspeed *ks;
1072
1073     while((resp = dc_getresp()) != NULL)
1074     {
1075         if(!wcscmp(resp->cmdname, L".connect"))
1076         {
1077             if(resp->code != 201)
1078             {
1079                 msgbox(GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, _("The server refused the connection"));
1080                 dc_disconnect();
1081                 dcdisconnected();
1082             } else if(dc_checkprotocol(resp, DC_LATEST)) {
1083                 msgbox(GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, _("Server protocol revision mismatch"));
1084                 dc_disconnect();
1085                 dcdisconnected();
1086             } else {
1087                 tosbuf = 0x10; /* Minimum cost */
1088                 setsockopt(dcfd, IPPROTO_IP, IP_TOS, &tosbuf, sizeof(tosbuf));
1089                 updatesbar(_("Connected"));
1090                 dc_loginasync(connectas, 1, loginconv, logincallback, NULL);
1091             }
1092         } else if(!wcscmp(resp->cmdname, L".notify")) {
1093             dc_uimisc_handlenotify(resp);
1094             switch(resp->code)
1095             {
1096             case 600:
1097                 if((ires = dc_interpret(resp)) != NULL)
1098                 {
1099                     if((fn = dc_findfnetnode(ires->argv[0].val.num)) != NULL)
1100                     {
1101                         fndata = fn->udata;
1102                         gtk_text_buffer_get_end_iter(fndata->textbuf, &iter);
1103                         if((buf = icwcstombs(ires->argv[3].val.str, "UTF-8")) != NULL)
1104                         {
1105                             gtk_text_buffer_insert_with_tags_by_name(fndata->textbuf, &iter, "<", -1, "sender", NULL);
1106                             gtk_text_buffer_insert_with_tags_by_name(fndata->textbuf, &iter, buf, -1, "sender", NULL);
1107                             gtk_text_buffer_insert_with_tags_by_name(fndata->textbuf, &iter, ">", -1, "sender", NULL);
1108                             gtk_text_buffer_insert(fndata->textbuf, &iter, " ", -1);
1109                             free(buf);
1110                         }
1111                         if((buf = icwcstombs(ires->argv[4].val.str, "UTF-8")) != NULL)
1112                         {
1113                             gtk_text_buffer_insert(fndata->textbuf, &iter, buf, -1);
1114                             gtk_text_buffer_insert(fndata->textbuf, &iter, "\n", -1);
1115                             free(buf);
1116                             if(curchat == fn->id)
1117                                 gtk_text_view_scroll_to_iter(GTK_TEXT_VIEW(main_chatview), &iter, 0, 0, 0, 0);
1118                         }
1119                     }
1120                     dc_freeires(ires);
1121                 }
1122                 break;
1123             case 601:
1124             case 602:
1125             case 603:
1126             case 604:
1127             case 605:
1128                 updatehublist();
1129                 break;
1130             case 610:
1131             case 611:
1132             case 612:
1133             case 613:
1134             case 614:
1135             case 615:
1136             case 616:
1137             case 617:
1138             case 618:
1139                 updatetransferlists();
1140                 break;
1141             case 620:
1142                 if((ires = dc_interpret(resp)) != NULL)
1143                 {
1144                     if(ires->argv[0].val.num == nextsrch)
1145                         srcheta = time(NULL) + ires->argv[0].val.num;
1146                     dc_freeires(ires);
1147                 }
1148                 break;
1149             case 621:
1150                 if((ires = dc_interpret(resp)) != NULL)
1151                 {
1152                     if(ires->argv[0].val.num == nextsrch)
1153                     {
1154                         if(cursrch != -1)
1155                             dc_queuecmd(NULL, NULL, L"cansrch", L"%i", cursrch, NULL);
1156                         cursrch = nextsrch;
1157                         nextsrch = -1;
1158                         gtk_widget_set_sensitive(main_realsrch, TRUE);
1159                         gtk_widget_set_sensitive(main_simplesrch, TRUE);
1160                         gtk_widget_set_sensitive(main_srchbtn, TRUE);
1161                         gtk_widget_set_sensitive(main_srchcanbtn, FALSE);
1162                         srchstatupdate();
1163                         gtk_entry_set_text(GTK_ENTRY(main_realsrch), "");
1164                         gtk_entry_set_text(GTK_ENTRY(main_simplesrch), "");
1165                         gtk_tree_store_clear(srchmodel);
1166                         freesrchsizes();
1167                     }
1168                     dc_freeires(ires);
1169                 }
1170                 break;
1171             case 622:
1172                 if((ires = dc_interpret(resp)) != NULL)
1173                 {
1174                     if(ires->argv[0].val.num == cursrch)
1175                     {
1176                         for(i = 0; i < numsizes; i++)
1177                         {
1178                             if(srchsizes[i].size == ires->argv[4].val.num)
1179                                 break;
1180                         }
1181                         if(i == numsizes)
1182                         {
1183                             srchsizes = srealloc(srchsizes, sizeof(*srchsizes) * ++numsizes);
1184                             srchsizes[i].size = ires->argv[4].val.num;
1185                             srchsizes[i].num = 1;
1186                             srchsizes[i].slots = ires->argv[5].val.num;
1187                             srchsizes[i].resptime = ires->argv[7].val.flnum;
1188                             ss = finddiscsize();
1189                             ss->slots += ires->argv[5].val.num;
1190                             if((ss->resptime == 0.0) || (ss->resptime > ires->argv[7].val.flnum))
1191                                 ss->resptime = ires->argv[7].val.flnum;
1192                             piter = *ref2iter(ss->ref);
1193                             gtk_tree_store_set(srchmodel, &piter, 5, ss->slots, 6, ss->resptime, -1);
1194                             gtk_tree_store_append(srchmodel, &titer, &piter);
1195                             srchsizes[i].ref = iter2ref(&titer);
1196                         } else if(srchsizes[i].num == 1) {
1197                             char *filename, *peername, *fnetname, *hash;
1198                             int slots, speed;
1199                             double resptime;
1200
1201                             gtk_tree_model_get(GTK_TREE_MODEL(srchmodel), ref2iter(srchsizes[i].ref), 0, &fnetname, 1, &peername, 3, &filename, 5, &slots, 6, &resptime, 8, &speed, 9, &hash, -1);
1202                             gtk_tree_store_remove(srchmodel, ref2iter(srchsizes[i].ref));
1203                             gtk_tree_row_reference_free(srchsizes[i].ref);
1204                             ss = finddiscsize();
1205                             ss->slots -= slots;
1206                             gtk_tree_store_set(srchmodel, ref2iter(ss->ref), 5, ss->slots, -1);
1207                             gtk_tree_store_append(srchmodel, &piter, NULL);
1208                             srchsizes[i].slots = ires->argv[5].val.num + slots;
1209                             srchsizes[i].resptime = (ires->argv[7].val.flnum < resptime)?ires->argv[7].val.flnum:resptime;
1210                             srchsizes[i].num = 2;
1211                             srchsizes[i].ref = iter2ref(&piter);
1212                             gtk_tree_store_set(srchmodel, &piter, 4, srchsizes[i].size, 5, srchsizes[i].slots, 6, srchsizes[i].resptime, 7, 2, -1);
1213                             if((buf = icwcstombs(ires->argv[1].val.str, "UTF-8")) != NULL)
1214                             {
1215                                 p = buf;
1216                                 /* XXX: Too NMDC-specific! */
1217                                 if(strrchr(p, '\\') != NULL)
1218                                     p = strrchr(p, '\\') + 1;
1219                                 gtk_tree_store_set(srchmodel, &piter, 3, p, -1);
1220                                 free(buf);
1221                             }
1222                             gtk_tree_store_append(srchmodel, &titer, &piter);
1223                             gtk_tree_store_set(srchmodel, &titer, 0, fnetname, 1, peername, 2, peername, 3, filename, 4, srchsizes[i].size, 5, slots, 6, resptime, 8, speed, 9, hash, -1);
1224                             g_free(filename); g_free(peername); g_free(fnetname); g_free(hash);
1225                             gtk_tree_store_append(srchmodel, &titer, &piter);
1226                         } else {
1227                             srchsizes[i].num++;
1228                             srchsizes[i].slots += ires->argv[5].val.num;
1229                             if(ires->argv[7].val.flnum < srchsizes[i].resptime)
1230                                 srchsizes[i].resptime = ires->argv[7].val.flnum;
1231                             piter = *ref2iter(srchsizes[i].ref);
1232                             gtk_tree_store_set(srchmodel, &piter, 5, srchsizes[i].slots, 6, srchsizes[i].resptime, 7, srchsizes[i].num, -1);
1233                             gtk_tree_store_append(srchmodel, &titer, &piter);
1234                         }
1235                         if((buf = icwcstombs(ires->argv[1].val.str, "UTF-8")) != NULL)
1236                         {
1237                             gtk_tree_store_set(srchmodel, &titer, 3, buf, -1);
1238                             free(buf);
1239                         }
1240                         if((buf = icwcstombs(ires->argv[2].val.str, "UTF-8")) != NULL)
1241                         {
1242                             gtk_tree_store_set(srchmodel, &titer, 0, buf, -1);
1243                             free(buf);
1244                         }
1245                         if((buf = icwcstombs(ires->argv[3].val.str, "UTF-8")) != NULL)
1246                         {
1247                             gtk_tree_store_set(srchmodel, &titer, 1, buf, -1);
1248                             gtk_tree_store_set(srchmodel, &titer, 2, buf, -1);
1249                             free(buf);
1250                         }
1251                         if((buf = icwcstombs(ires->argv[8].val.str, "UTF-8")) != NULL)
1252                         {
1253                             gtk_tree_store_set(srchmodel, &titer, 9, buf, -1);
1254                             free(buf);
1255                         }
1256                         gtk_tree_store_set(srchmodel, &titer, 4, ires->argv[4].val.num, 5, ires->argv[5].val.num, 6, ires->argv[7].val.flnum, 8, -1, -1);
1257                     }
1258                     dc_freeires(ires);
1259                 }
1260                 break;
1261             default:
1262                 break;
1263             }
1264         } else if(!wcscmp(resp->cmdname, L"filtercmd")) {
1265             if((ksquerytag >= 0) && (ksquerytag == resp->tag))
1266             {
1267                 for(i = 0; i < resp->numlines; i++)
1268                 {
1269                     assert((ks = findksentbyseq(i)) != NULL);
1270                     ks->speed = wcstol(resp->rlines[i].argv[1], NULL, 10);
1271                     ks->seq = -1;
1272                     ks->fetched = time(NULL);
1273                 }
1274                 ksquerytag = -1;
1275                 ksupdatecb(NULL);
1276             } else if((lsrestag >= 0) && (lsrestag == resp->tag)) {
1277                 for(i = 0; i < resp->numlines; i++)
1278                 {
1279                     if(!wcsncmp(resp->rlines[i].argv[1], L"id:", 3))
1280                     {
1281                         gtk_list_store_append(reslist, &titer);
1282                         gtk_list_store_set(reslist, &titer, 0, icswcstombs(resp->rlines[i].argv[1] + 3, "UTF-8", NULL), -1);
1283                     } else if(!wcsncmp(resp->rlines[i].argv[1], L"size:", 5)) {
1284                         gtk_list_store_set(reslist, &titer, 1, wcstol(resp->rlines[i].argv[1] + 5, NULL, 10), -1);
1285                     } else if(!wcsncmp(resp->rlines[i].argv[1], L"prog:", 5)) {
1286                         gtk_list_store_set(reslist, &titer, 2, wcstol(resp->rlines[i].argv[1] + 5, NULL, 10), -1);
1287                     } else if(!wcsncmp(resp->rlines[i].argv[1], L"name:", 5)) {
1288                         gtk_list_store_set(reslist, &titer, 3, icswcstombs(resp->rlines[i].argv[1] + 5, "UTF-8", NULL), -1);
1289                     } else if(!wcsncmp(resp->rlines[i].argv[1], L"lock:", 5)) {
1290                         if(!wcscmp(resp->rlines[i].argv[1] + 5, L"yes"))
1291                             gtk_list_store_set(reslist, &titer, 4, TRUE, -1);
1292                         else
1293                             gtk_list_store_set(reslist, &titer, 4, FALSE, -1);
1294                     } else if(!wcsncmp(resp->rlines[i].argv[1], L"hash:", 5)) {
1295                         gtk_list_store_set(reslist, &titer, 5, icswcstombs(resp->rlines[i].argv[1] + 5, "UTF-8", NULL), -1);
1296                     }
1297                 }
1298                 lsrestag = -1;
1299                 gtk_widget_set_sensitive(reslist_reload, TRUE);
1300             }
1301         }
1302         dc_freeresp(resp);
1303     }
1304     updatewrite();
1305 }
1306
1307 void dcfdcallback(gpointer data, gint source, GdkInputCondition condition)
1308 {
1309     int errnobak;
1310
1311     if(((condition & GDK_INPUT_READ) && dc_handleread()) || ((condition & GDK_INPUT_WRITE) && dc_handlewrite()))
1312     {
1313         errnobak = errno;
1314         dcdisconnected();
1315         if(errnobak == 0)
1316         {
1317             msgbox(GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, _("The server has closed the connection"));
1318         } else {
1319             msgbox(GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, _("The connection to the server failed:\n\n%s"), strerror(errnobak));
1320         }
1321         return;
1322     }
1323     handleresps();
1324 }
1325
1326 void cb_main_dconnmenu_activate(GtkWidget *widget, gpointer data)
1327 {
1328     if(dcfd < 0)
1329         return;
1330     dc_disconnect();
1331     dcdisconnected();
1332 }
1333
1334 void cb_main_prefmenu_activate(GtkWidget *widget, gpointer data)
1335 {
1336     GtkWidget *dialog, *swnd;
1337     int resp;
1338
1339     dialog = gtk_dialog_new_with_buttons(_("Preferences"), GTK_WINDOW(main_wnd), GTK_DIALOG_MODAL, GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, NULL);
1340     gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), swnd = create_pref_wnd(), TRUE, TRUE, 0);
1341     gtk_entry_set_text(GTK_ENTRY(pref_pubhuburl), pubhubaddr);
1342     gtk_entry_set_text(GTK_ENTRY(pref_connectas), connectas);
1343     gtk_entry_set_text(GTK_ENTRY(pref_dcserver), dcserver);
1344     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(pref_autoconn), autoconn);
1345     gtk_widget_show(swnd);
1346     resp = gtk_dialog_run(GTK_DIALOG(dialog));
1347     if(resp == GTK_RESPONSE_ACCEPT)
1348     {
1349         free(pubhubaddr);
1350         pubhubaddr = sstrdup(gtk_entry_get_text(GTK_ENTRY(pref_pubhuburl)));
1351         free(connectas);
1352         connectas = sstrdup(gtk_entry_get_text(GTK_ENTRY(pref_connectas)));
1353         free(dcserver);
1354         dcserver = sstrdup(gtk_entry_get_text(GTK_ENTRY(pref_dcserver)));
1355         autoconn = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(pref_autoconn));
1356     }
1357     gtk_widget_destroy(dialog);
1358 }
1359
1360 void cb_main_lsres_activate(GtkWidget *widget, gpointer data)
1361 {
1362     gtk_list_store_clear(reslist);
1363     gtk_widget_set_sensitive(reslist_delete, FALSE);
1364     gtk_widget_set_sensitive(reslist_search, FALSE);
1365     gtk_widget_show(reslist_wnd);
1366     if(lsrestag == -1)
1367     {
1368         lsrestag = dc_queuecmd(NULL, NULL, L"filtercmd", L"lsres", NULL);
1369         gtk_widget_set_sensitive(reslist_reload, FALSE);
1370     }
1371 }
1372
1373 void dcconnect(char *host)
1374 {
1375     dcfd = dc_connect(host);
1376     if(dcfd < 0)
1377     {
1378         msgbox(GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, _("Could not connect:\n\n%s"), strerror(errno));
1379         return;
1380     }
1381     gdkread = gdk_input_add(dcfd, GDK_INPUT_READ, dcfdcallback, NULL);
1382     updatewrite();
1383     gtk_widget_set_sensitive(main_connmenu, FALSE);
1384     gtk_widget_set_sensitive(main_dconnmenu, TRUE);
1385     updatesbar(_("Connecting..."));
1386 }
1387
1388 void cb_main_connmenu_activate(GtkWidget *widget, gpointer data)
1389 {
1390     char *buf;
1391
1392     if(dcfd >= 0)
1393         return;
1394     if((buf = inputbox(_("Connect"), _("Server address:"), dcserver, 1)) == NULL)
1395         return;
1396     dcconnect(buf);
1397     free(buf);
1398 }
1399
1400 void cb_main_sdmenu_activate(GtkWidget *widget, gpointer data)
1401 {
1402     int tag;
1403     struct dc_response *resp;
1404
1405     if(dcfd < 0)
1406     {
1407         msgbox(GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, _("Not connected to DC server"));
1408         return;
1409     }
1410     tag = dc_queuecmd(NULL, NULL, L"shutdown", NULL);
1411     if((resp = dc_gettaggedrespsync(tag)) != NULL)
1412     {
1413         if(resp->code == 502)
1414             msgbox(GTK_MESSAGE_WARNING, GTK_BUTTONS_OK, _("You do not have permission to do that"));
1415         dc_freeresp(resp);
1416     }
1417     handleresps();
1418 }
1419
1420 void cb_main_fnaddr_activate(GtkWidget *widget, gpointer data)
1421 {
1422     int tag;
1423     struct dc_response *resp;
1424     wchar_t **toks;
1425
1426     if(dcfd < 0)
1427     {
1428         msgbox(GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, _("Not connected to DC server"));
1429         return;
1430     }
1431     toks = dc_lexsexpr(icsmbstowcs((char *)gtk_entry_get_text(GTK_ENTRY(main_fnaddr)), "UTF-8", NULL));
1432     if(*toks == NULL)
1433     {
1434         msgbox(GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, _("Illegal address entered"));
1435         return;
1436     }
1437     if(wcschr(toks[0], L':') == NULL)
1438     {
1439         toks[0] = srealloc(toks[0], (wcslen(toks[0]) + 5) * sizeof(wchar_t));
1440         wcscat(toks[0], L":411");
1441     }
1442     tag = dc_queuecmd(NULL, NULL, L"cnct", L"dc", L"%a", toks, NULL);
1443     dc_freewcsarr(toks);
1444     if((resp = dc_gettaggedrespsync(tag)) != NULL)
1445     {
1446         if(resp->code == 502)
1447             msgbox(GTK_MESSAGE_WARNING, GTK_BUTTONS_OK, _("You do not have permission to do that"));
1448         if(resp->code == 509)
1449             msgbox(GTK_MESSAGE_WARNING, GTK_BUTTONS_OK, _("The server could not parse that address"));
1450         if(resp->code == 515)
1451             msgbox(GTK_MESSAGE_WARNING, GTK_BUTTONS_OK, _("There are too many hubs connected"));
1452         dc_freeresp(resp);
1453     }
1454     gtk_entry_set_text(GTK_ENTRY(main_fnaddr), "");
1455     handleresps();
1456 }
1457
1458 void setpubhubmodel(GtkTreeModel *model, int sortcol, int numcols, int *cols, char **names)
1459 {
1460     GtkTreeViewColumn *col;
1461     GtkCellRenderer *rnd;
1462     GtkTreeModel *sortmodel;
1463     int i;
1464
1465     while((col = gtk_tree_view_get_column(GTK_TREE_VIEW(main_phublist), 0)) != NULL)
1466         gtk_tree_view_remove_column(GTK_TREE_VIEW(main_phublist), col);
1467     for(i = 0; i < numcols; i++) {
1468         if(gtk_tree_model_get_column_type(model, cols[i]) == G_TYPE_INT64)
1469         {
1470             col = gtk_tree_view_column_new();
1471             gtk_tree_view_column_set_title(col, names[i]);
1472             rnd = gtk_cell_renderer_text_new();
1473             gtk_tree_view_column_pack_start(col, rnd, TRUE);
1474             gtk_tree_view_column_set_cell_data_func(col, rnd, transnicebytefunc2, GINT_TO_POINTER(cols[i]), NULL);
1475         } else {
1476             col = gtk_tree_view_column_new_with_attributes(names[i], gtk_cell_renderer_text_new(), "text", cols[i], NULL);
1477         }
1478         gtk_tree_view_column_set_sort_column_id(col, cols[i]);
1479         gtk_tree_view_column_set_resizable(col, TRUE);
1480         gtk_tree_view_append_column(GTK_TREE_VIEW(main_phublist), col);
1481     }
1482     sortmodel = gtk_tree_model_sort_new_with_model(model);
1483     gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(sortmodel), sortcol, GTK_SORT_DESCENDING);
1484     gtk_tree_view_set_model(GTK_TREE_VIEW(main_phublist), sortmodel);
1485     g_object_unref(sortmodel);
1486 }
1487
1488 xmlNodePtr findnode(xmlNodePtr node, char *name)
1489 {
1490     for(; node != NULL; node = node->next)
1491     {
1492         if(!strcmp((char *)node->name, name))
1493             break;
1494     }
1495     return(node);
1496 }
1497
1498 int pubhubxmlhandler(int op, char *buf, size_t *len)
1499 {
1500     static xmlParserCtxtPtr ctxt = NULL;
1501     int i, match;
1502     xmlNodePtr dr, r, cr, c, n;
1503     int numcols, *cols, sortcol;
1504     GType type, *types;
1505     char **names, *name, *stype, *attr;
1506     GtkListStore *model;
1507     GtkTreeIter iter;
1508
1509     numcols = 0;
1510     names = NULL;
1511     types = NULL;
1512     switch(op)
1513     {
1514     case PHO_INIT:
1515         break;
1516     case PHO_DATA:
1517         if(ctxt == NULL) {
1518             ctxt = xmlCreatePushParserCtxt(NULL, NULL, buf, *len, pubhubaddr);
1519             *len = 0;
1520             if(ctxt == NULL)
1521                 return(1);
1522         } else {
1523             xmlParseChunk(ctxt, buf, *len, 0);
1524             *len = 0;
1525         }
1526         break;
1527     case PHO_EOF:
1528         if(ctxt == NULL)
1529         {
1530             msgbox(GTK_MESSAGE_WARNING, GTK_BUTTONS_OK, _("A hub list could not be read from %s"), pubhubaddr);
1531             break;
1532         }
1533         xmlParseChunk(ctxt, NULL, 0, 1);
1534         if(!ctxt->wellFormed)
1535         {
1536             msgbox(GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, _("The hub list at %s is not valid"), pubhubaddr);
1537             break;
1538         }
1539         dr = r = cr = NULL;
1540         dr = xmlDocGetRootElement(ctxt->myDoc);
1541         if(dr != NULL)
1542             r = findnode(dr->children, "Hubs");
1543         if(r != NULL)
1544             cr = findnode(r->children, "Columns");
1545         if(cr == NULL)
1546         {
1547             msgbox(GTK_MESSAGE_WARNING, GTK_BUTTONS_OK, _("The hub list at %s cannot be understood"), pubhubaddr);
1548             break;
1549         }
1550         for(c = findnode(cr->children, "Column"); c != NULL; c = findnode(c->next, "Column"))
1551         {
1552             name = (char *)xmlGetProp(c, (xmlChar *)"Name");
1553             stype = (char *)xmlGetProp(c, (xmlChar *)"Type");
1554             type = G_TYPE_INVALID;
1555             if(stype != NULL)
1556             {
1557                 if(!strcmp(stype, "string"))
1558                     type = G_TYPE_STRING;
1559                 else if(!strcmp(stype, "int"))
1560                     type = G_TYPE_INT;
1561                 else if(!strcmp(stype, "bytes"))
1562                     type = G_TYPE_INT64;
1563             }
1564             if((name != NULL) && (type != G_TYPE_INVALID))
1565             {
1566                 names = srealloc(names, (numcols + 1) * sizeof(*names));
1567                 types = srealloc(types, (numcols + 1) * sizeof(*names));
1568                 names[numcols] = sstrdup(name);
1569                 types[numcols] = type;
1570                 numcols++;
1571             }
1572             if(name != NULL)
1573                 xmlFree(name);
1574             if(stype != NULL)
1575                 xmlFree(stype);
1576         }
1577         if(numcols == 0)
1578         {
1579             msgbox(GTK_MESSAGE_WARNING, GTK_BUTTONS_OK, _("The hub list at %s did not contain any columns"), pubhubaddr);
1580             break;
1581         }
1582         for(i = 0; i < numcols; i++)
1583         {
1584             if(!strcmp(names[i], "Address"))
1585             {
1586                 name = names[0];
1587                 names[0] = names[i];
1588                 names[i] = name;
1589                 type = types[0];
1590                 types[0] = types[i];
1591                 types[i] = type;
1592                 break;
1593             }
1594         }
1595         if(i == numcols)
1596         {
1597             msgbox(GTK_MESSAGE_WARNING, GTK_BUTTONS_OK, _("The hub list at %s did not contain the address to any hubs"), pubhubaddr);
1598             break;
1599         }
1600         model = gtk_list_store_newv(numcols, types);
1601         for(n = findnode(r->children, "Hub"); n != NULL; n = findnode(n->next, "Hub"))
1602         {
1603             if(!xmlHasProp(n, (xmlChar *)"Address") || !xmlHasProp(n, (xmlChar *)"Name"))
1604                 continue;
1605             if(filterpubhub)
1606             {
1607                 match = 0;
1608                 attr = (char *)xmlGetProp(n, (xmlChar *)"Name");
1609                 if(!regexec(&pubhubfilter, attr, 0, NULL, 0))
1610                     match = 1;
1611                 xmlFree(attr);
1612                 if((attr = (char *)xmlGetProp(n, (xmlChar *)"Description")) != NULL)
1613                 {
1614                     if(!regexec(&pubhubfilter, attr, 0, NULL, 0))
1615                         match = 1;
1616                     xmlFree(attr);
1617                 }
1618                 if(!match)
1619                     continue;
1620             }
1621             gtk_list_store_append(model, &iter);
1622             for(i = 0; i < numcols; i++)
1623             {
1624                 attr = (char *)xmlGetProp(n, (xmlChar *)names[i]);
1625                 if(attr != NULL)
1626                 {
1627                     if(types[i] == G_TYPE_STRING)
1628                         gtk_list_store_set(model, &iter, i, attr, -1);
1629                     else if(types[i] == G_TYPE_INT)
1630                         gtk_list_store_set(model, &iter, i, atoi(attr), -1);
1631                     else if(types[i] == G_TYPE_INT64)
1632                         gtk_list_store_set(model, &iter, i, strtoll(attr, NULL, 0), -1);
1633                     xmlFree(attr);
1634                 }
1635             }
1636         }
1637         cols = smalloc((numcols - 1) * sizeof(*cols));
1638         for(i = 1; i < numcols; i++)
1639             cols[i - 1] = i;
1640         sortcol = 0;
1641         for(i = 0; i < numcols; i++)
1642         {
1643             if(!strcmp(names[i], "Users"))
1644                 sortcol = i;
1645         }
1646         setpubhubmodel(GTK_TREE_MODEL(model), sortcol, numcols - 1, cols, names + 1);
1647         free(cols);
1648         g_object_unref(model);
1649         break;
1650     case PHO_FINI:
1651         if(ctxt != NULL)
1652         {
1653             if(ctxt->myDoc != NULL)
1654                 xmlFreeDoc(ctxt->myDoc);
1655             xmlFreeParserCtxt(ctxt);
1656             ctxt = NULL;
1657         }
1658         break;
1659     }
1660     if(numcols != 0)
1661     {
1662         for(i = 0; i < numcols; i++)
1663             free(names[i]);
1664         free(names);
1665         free(types);
1666     }
1667     return(0);
1668 }
1669
1670 int pubhuboldhandler(int op, char *buf, size_t *len)
1671 {
1672     static GtkListStore *model = NULL;
1673     int i;
1674     char *p, *p2;
1675     wchar_t *wbuf;
1676     char *fields[4], *names[3];
1677     int cols[3];
1678     GtkTreeIter iter;
1679
1680     switch(op)
1681     {
1682     case PHO_INIT:
1683         model = gtk_list_store_new(4, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT);
1684         break;
1685     case PHO_DATA:
1686         while((p = memchr(buf, '\n', *len)) != NULL)
1687         {
1688             *(p++) = 0;
1689             for(i = 0, p2 = buf; i < 4; i++) {
1690                 fields[i] = p2;
1691                 if((p2 = strchr(p2, '|')) == NULL)
1692                     break;
1693                 *(p2++) = 0;
1694             }
1695             if(i == 4) {
1696                 for(i = 0; i < 4; i++) {
1697                     if((wbuf = icsmbstowcs(fields[i], DCCHARSET, NULL)) == NULL) {
1698                         fields[i] = sstrdup(_("(Invalid character)"));
1699                     } else {
1700                         if((fields[i] = icwcstombs(wbuf, "UTF-8")) == NULL)
1701                             break;
1702                     }
1703                 }
1704                 if(i == 4) {
1705                     if(!filterpubhub || !regexec(&pubhubfilter, fields[0], 0, NULL, 0) || !regexec(&pubhubfilter, fields[2], 0, NULL, 0)) {
1706                         gtk_list_store_append(model, &iter);
1707                         gtk_list_store_set(model, &iter, 0, fields[1], 1, fields[0], 2, fields[2], 3, atoi(fields[3]), -1);
1708                     }
1709                 }
1710                 for(i--; i >= 0; i--)
1711                     free(fields[i]);
1712             }
1713             memmove(buf, p, *len -= p - buf);
1714         }
1715         break;
1716     case PHO_EOF:
1717         cols[0] = 3; names[0] = _("# users");
1718         cols[1] = 1; names[1] = _("Name");
1719         cols[2] = 2; names[2] = _("Description");
1720         setpubhubmodel(GTK_TREE_MODEL(model), 3, 3, cols, names);
1721         break;
1722     case PHO_FINI:
1723         if(model != NULL)
1724             g_object_unref(model);
1725         model = NULL;
1726         break;
1727     }
1728     return(0);
1729 }
1730
1731 void pubhubfdcallback(gpointer data, gint source, GdkInputCondition condition)
1732 {
1733     static char buf[65536];
1734     static size_t bufpos = 0;
1735     int ret, reset;
1736
1737     if(!(condition & GDK_INPUT_READ))
1738         return;
1739     if(bufpos == sizeof(buf))
1740         bufpos = 0;
1741     ret = read(pubhubfd, buf + bufpos, sizeof(buf) - bufpos);
1742     reset = 0;
1743     if(ret <= 0)
1744     {
1745         if(ret < 0)
1746             msgbox(GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, _("Could not read from public hub listing process: %s"), strerror(errno));
1747         else
1748             pubhubhandler(PHO_EOF, NULL, NULL);
1749         reset = 1;
1750     } else {
1751         bufpos += ret;
1752         if(pubhubhandler(PHO_DATA, buf, &bufpos))
1753             reset = 1;
1754     }
1755     if(reset)
1756     {
1757         pubhubhandler(PHO_FINI, NULL, NULL);
1758         pubhubhandler = NULL;
1759         gdk_input_remove(pubhubtag);
1760         close(pubhubfd);
1761         kill(pubhubproc, SIGINT);
1762         pubhubfd = pubhubtag = -1;
1763         pubhubproc = 0;
1764         bufpos = 0;
1765         if(filterpubhub)
1766         {
1767             regfree(&pubhubfilter);
1768             filterpubhub = 0;
1769         }
1770     }
1771 }
1772
1773 void cb_main_pubhubfilter_activate(GtkWidget *widget, gpointer data)
1774 {
1775     int pipe1[2], pipe2[2];
1776     int len, err;
1777     const char *buf, *p;
1778     char errbuf[1024];
1779
1780     if(pubhubtag >= 0)
1781         gdk_input_remove(pubhubtag);
1782     if(pubhubfd >= 0)
1783         close(pubhubfd);
1784     if(pubhubproc > 0)
1785         kill(pubhubproc, SIGINT);
1786     if(pubhubhandler != NULL)
1787     {
1788         pubhubhandler(PHO_FINI, NULL, NULL);
1789         pubhubhandler = NULL;
1790     }
1791     if(filterpubhub)
1792     {
1793         regfree(&pubhubfilter);
1794         filterpubhub = 0;
1795     }
1796     buf = gtk_entry_get_text(GTK_ENTRY(main_pubhubfilter));
1797     if(*buf)
1798     {
1799         if((err = regcomp(&pubhubfilter, buf, REG_EXTENDED | REG_ICASE | REG_NOSUB)) != 0)
1800         {
1801             regerror(err, &pubhubfilter, errbuf, sizeof(errbuf));
1802             msgbox(GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "Could not compile regex: %s", errbuf);
1803             regfree(&pubhubfilter);
1804             filterpubhub = 0;
1805             return;
1806         }
1807         filterpubhub = 1;
1808     }
1809     pipe(pipe1);
1810     if((pubhubproc = fork()) == 0)
1811     {
1812         dup2(pipe1[1], 1);
1813         close(pipe1[0]);
1814         close(pipe1[1]);
1815         execlp("wget", "wget", "-qO", "-", pubhubaddr, NULL);
1816         perror("wget");
1817         exit(127);
1818     }
1819     close(pipe1[1]);
1820     pubhubfd = pipe1[0];
1821     len = strlen(pubhubaddr);
1822     p = pubhubaddr + len;
1823     if((len > 4) && !strncmp(p - 4, ".bz2", 4))
1824     {
1825         p -= 4;
1826         len -= 4;
1827         pipe(pipe2);
1828         if(fork() == 0)
1829         {
1830             dup2(pipe1[0], 0);
1831             dup2(pipe2[1], 1);
1832             close(pipe1[0]);
1833             close(pipe2[0]);
1834             close(pipe2[1]);
1835             execlp("bzcat", "bzcat", NULL);
1836             perror("bzcat");
1837             exit(127);
1838         }
1839         close(pipe1[0]);
1840         close(pipe2[1]);
1841         pubhubfd = pipe2[0];
1842     }
1843     if((len > 4) && !strncmp(p - 4, ".xml", 4))
1844     {
1845         p -= 4;
1846         len -= 4;
1847         pubhubhandler = pubhubxmlhandler;
1848     } else {
1849         pubhubhandler = pubhuboldhandler;
1850     }
1851     pubhubhandler(PHO_INIT, NULL, NULL);
1852     pubhubtag = gdk_input_add(pubhubfd, GDK_INPUT_READ, pubhubfdcallback, NULL);
1853 }
1854
1855 void cb_main_dcnctbtn_clicked(GtkWidget *widget, gpointer data)
1856 {
1857     GtkTreeIter iter;
1858     int tag, id;
1859     struct dc_response *resp;
1860
1861     if(dcfd < 0)
1862     {
1863         msgbox(GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, _("Not connected to DC server"));
1864         return;
1865     }
1866     if(!gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(main_fnetnodes)), NULL, &iter))
1867     {
1868         msgbox(GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, _("No hub selected"));
1869         return;
1870     }
1871     gtk_tree_model_get(GTK_TREE_MODEL(fnmodel), &iter, 0, &id, -1);
1872     tag = dc_queuecmd(NULL, NULL, L"dcnct", L"%i", id, NULL);
1873     if((resp = dc_gettaggedrespsync(tag)) != NULL)
1874     {
1875         if(resp->code == 502)
1876             msgbox(GTK_MESSAGE_WARNING, GTK_BUTTONS_OK, _("You do not have permission to do that"));
1877         dc_freeresp(resp);
1878     }
1879     handleresps();
1880 }
1881
1882 void cb_main_phublist_cchange(GtkWidget *widget, gpointer data)
1883 {
1884     GtkTreeIter iter;
1885     GtkTreeModel *model;
1886     char *addr;
1887
1888     if(!gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(main_phublist)), &model, &iter))
1889         return;
1890     gtk_tree_model_get(GTK_TREE_MODEL(model), &iter, 0, &addr, -1);
1891     gtk_entry_set_text(GTK_ENTRY(main_fnaddr), addr);
1892     g_free(addr);
1893 }
1894
1895 void cb_main_phublist_activate(GtkWidget *widget, GtkTreePath *path, GtkTreeViewColumn *col, gpointer data)
1896 {
1897     int tag;
1898     struct dc_response *resp;
1899     GtkTreeIter iter;
1900     GtkTreeModel *model;
1901     char *buf;
1902
1903     if(dcfd < 0)
1904     {
1905         msgbox(GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, _("Not connected to DC server"));
1906         return;
1907     }
1908     model = gtk_tree_view_get_model(GTK_TREE_VIEW(widget));
1909     if(!gtk_tree_model_get_iter(GTK_TREE_MODEL(model), &iter, path))
1910         return;
1911     gtk_tree_model_get(GTK_TREE_MODEL(model), &iter, 0, &buf, -1);
1912     if(strchr(buf, ':') == NULL)
1913     {
1914         buf = g_realloc(buf, strlen(buf) + 5);
1915         strcat(buf, ":411");
1916     }
1917     tag = dc_queuecmd(NULL, NULL, L"cnct", L"dc", L"%s", buf, NULL);
1918     g_free(buf);
1919     gtk_entry_set_text(GTK_ENTRY(main_fnaddr), "");
1920     if((resp = dc_gettaggedrespsync(tag)) != NULL)
1921     {
1922         if(resp->code == 502)
1923             msgbox(GTK_MESSAGE_WARNING, GTK_BUTTONS_OK, _("You do not have permission to do that"));
1924         if(resp->code == 509)
1925             msgbox(GTK_MESSAGE_WARNING, GTK_BUTTONS_OK, _("The server could not parse that address"));
1926         if(resp->code == 515)
1927             msgbox(GTK_MESSAGE_WARNING, GTK_BUTTONS_OK, _("There are too many hubs connected"));
1928         dc_freeresp(resp);
1929     }
1930     handleresps();
1931 }
1932
1933 void cb_main_chatnodes_activate(GtkWidget *widget, GtkTreePath *path, GtkTreeViewColumn *col, gpointer uudata)
1934 {
1935     GtkTreeIter iter;
1936     int id;
1937     struct dc_fnetnode *fn;
1938     struct fndata *data;
1939
1940     if(!gtk_tree_model_get_iter(GTK_TREE_MODEL(fnmodel), &iter, path))
1941         return;
1942     gtk_tree_model_get(GTK_TREE_MODEL(fnmodel), &iter, 0, &id, -1);
1943     if((fn = dc_findfnetnode(id)) == NULL)
1944         return;
1945     data = fn->udata;
1946     curchat = id;
1947     if(gtk_tree_model_get_iter_first(GTK_TREE_MODEL(fnmodel), &iter))
1948     {
1949         do
1950         {
1951             gtk_tree_model_get(GTK_TREE_MODEL(fnmodel), &iter, 0, &id, -1);
1952             if(id == curchat)
1953                 gtk_list_store_set(fnmodel, &iter, 5, "gtk-apply", -1);
1954             else
1955                 gtk_list_store_set(fnmodel, &iter, 5, NULL, -1);
1956         } while(gtk_tree_model_iter_next(GTK_TREE_MODEL(fnmodel), &iter));
1957     }
1958     gtk_text_view_set_buffer(GTK_TEXT_VIEW(main_chatview), GTK_TEXT_BUFFER(data->textbuf));
1959 }
1960
1961 void cb_main_chatstr_activate(GtkWidget *widget, gpointer data)
1962 {
1963     int tag;
1964     const char *buf;
1965     struct dc_response *resp;
1966
1967     if(dcfd < 0)
1968     {
1969         msgbox(GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, _("Not connected to DC server"));
1970         return;
1971     }
1972     if(curchat < 0)
1973     {
1974         msgbox(GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, _("No hub selected"));
1975         return;
1976     }
1977     buf = gtk_entry_get_text(GTK_ENTRY(main_chatstr));
1978     tag = dc_queuecmd(NULL, NULL, L"sendchat", L"%i", curchat, L"1", L"", L"%s", buf, NULL);
1979     if((resp = dc_gettaggedrespsync(tag)) != NULL)
1980     {
1981         if(resp->code == 502)
1982             msgbox(GTK_MESSAGE_WARNING, GTK_BUTTONS_OK, _("You do not have permission to do that"));
1983         else if(resp->code == 504)
1984             msgbox(GTK_MESSAGE_WARNING, GTK_BUTTONS_OK, _("This hub could not support all the types of characters in your chat message"));
1985         else if(resp->code == 513)
1986             msgbox(GTK_MESSAGE_WARNING, GTK_BUTTONS_OK, _("This hub does not support chatting"));
1987         else if(resp->code != 200)
1988             msgbox(GTK_MESSAGE_WARNING, GTK_BUTTONS_OK, _("An error occurred while trying to chat (%i)"), resp->code);
1989         dc_freeresp(resp);
1990     }
1991     gtk_entry_set_text(GTK_ENTRY(main_chatstr), "");
1992     handleresps();
1993 }
1994
1995 void updatesrchfld(const char *simple)
1996 {
1997     char *buf, *s;
1998     char *p, *p2;
1999     size_t bufsize, bufdata;
2000
2001     s = sstrdup(simple);
2002     buf = NULL;
2003     bufsize = bufdata = 0;
2004     p = s;
2005     do
2006     {
2007         p2 = strchr(p, ' ');
2008         if(p2 != NULL)
2009             *(p2++) = 0;
2010         if(*p)
2011         {
2012             if(bufdata > 0)
2013                 bufcat(buf, " & ", 3);
2014             bufcat(buf, "N~", 2);
2015             for(; *p; p++)
2016             {
2017                 if(strchr("[]()$^.*?+\\|\"!", *p) != NULL)
2018                     addtobuf(buf, '\\');
2019                 addtobuf(buf, *p);
2020             }
2021         }
2022         p = p2;
2023     } while(p2 != NULL);
2024     addtobuf(buf, 0);
2025     gtk_entry_set_text(GTK_ENTRY(main_realsrch), buf);
2026     free(buf);
2027     free(s);
2028 }
2029
2030 void cb_main_simplesrch_changed(GtkWidget *widget, gpointer data)
2031 {
2032     if(srchautoupdate)
2033         return;
2034     srchautoupdate = 1;
2035     updatesrchfld(gtk_entry_get_text(GTK_ENTRY(main_simplesrch)));
2036     srchautoupdate = 0;
2037 }
2038
2039 void cb_main_realsrch_changed(GtkWidget *widget, gpointer data)
2040 {
2041     if(srchautoupdate)
2042         return;
2043     srchautoupdate = 1;
2044     gtk_entry_set_text(GTK_ENTRY(main_simplesrch), "");
2045     srchautoupdate = 0;
2046 }
2047
2048 void cb_main_srchbtn_clicked(GtkWidget *widget, gpointer data)
2049 {
2050     wchar_t **toks;
2051     int tag;
2052     struct dc_response *resp;
2053     struct dc_intresp *ires;
2054
2055     if(dcfd < 0)
2056     {
2057         msgbox(GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, _("Not connected to DC server"));
2058         return;
2059     }
2060     if(nextsrch != -1) /* Impossible case, but oh well... */
2061         return;
2062     toks = dc_lexsexpr(icsmbstowcs((char *)gtk_entry_get_text(GTK_ENTRY(main_realsrch)), "UTF-8", NULL));
2063     if(*toks == NULL)
2064     {
2065         msgbox(GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, _("Please enter a search expression before searching"));
2066         return;
2067     }
2068     tag = dc_queuecmd(NULL, NULL, L"search", L"all", L"%a", toks, NULL);
2069     dc_freewcsarr(toks);
2070     if((resp = dc_gettaggedrespsync(tag)) != NULL)
2071     {
2072         if(resp->code == 501)
2073             msgbox(GTK_MESSAGE_WARNING, GTK_BUTTONS_OK, _("Could not find any hubs to search on"));
2074         else if(resp->code == 502)
2075             msgbox(GTK_MESSAGE_WARNING, GTK_BUTTONS_OK, _("You do not have permission to do that"));
2076         else if(resp->code == 509)
2077             msgbox(GTK_MESSAGE_WARNING, GTK_BUTTONS_OK, _("The server could not parse your search expression"));
2078         else if(resp->code != 200)
2079             msgbox(GTK_MESSAGE_WARNING, GTK_BUTTONS_OK, _("An error occurred while trying to search (%i)"), resp->code);
2080         if(resp->code == 200)
2081         {
2082             if((ires = dc_interpret(resp)) != NULL)
2083             {
2084                 nextsrch = ires->argv[0].val.num;
2085                 srcheta = time(NULL) + ires->argv[1].val.num;
2086                 dc_freeires(ires);
2087             }
2088             gtk_widget_set_sensitive(main_realsrch, FALSE);
2089             gtk_widget_set_sensitive(main_simplesrch, FALSE);
2090             gtk_widget_set_sensitive(main_srchbtn, FALSE);
2091             gtk_widget_set_sensitive(main_srchcanbtn, TRUE);
2092             srchstatupdate();
2093         }
2094         dc_freeresp(resp);
2095     }
2096     handleresps();
2097 }
2098
2099 void cb_main_srchcanbtn_clicked(GtkWidget *widget, gpointer data)
2100 {
2101     if(nextsrch == -1)
2102         return;
2103     dc_queuecmd(NULL, NULL, L"cansrch", L"%i", nextsrch, NULL);
2104     nextsrch = -1;
2105     gtk_widget_set_sensitive(main_realsrch, TRUE);
2106     gtk_widget_set_sensitive(main_simplesrch, TRUE);
2107     gtk_widget_set_sensitive(main_srchbtn, TRUE);
2108     gtk_widget_set_sensitive(main_srchcanbtn, FALSE);
2109     srchstatupdate();
2110 }
2111
2112 gboolean cb_main_trlist_keypress(GtkWidget *widget, GdkEventKey *event, gpointer data)
2113 {
2114     int id, tag;
2115     GtkTreeSelection *sel;
2116     GtkTreeModel *model;
2117     GtkTreeIter iter;
2118     struct dc_response *resp;
2119
2120     if((event->type == GDK_KEY_PRESS) && (event->keyval == GDK_Delete))
2121     {
2122         sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(widget));
2123         if(gtk_tree_selection_get_selected(sel, &model, &iter))
2124         {
2125             gtk_tree_model_get(model, &iter, 0, &id, -1);
2126             tag = dc_queuecmd(NULL, NULL, L"cancel", L"%i", id, NULL);
2127             if((resp = dc_gettaggedrespsync(tag)) != NULL)
2128             {
2129                 if(resp->code == 502)
2130                     msgbox(GTK_MESSAGE_WARNING, GTK_BUTTONS_OK, _("You do not have permission to do that"));
2131                 else if(resp->code != 200)
2132                     msgbox(GTK_MESSAGE_WARNING, GTK_BUTTONS_OK, _("An error occurred while trying to cancel (%i)"), resp->code);
2133                 dc_freeresp(resp);
2134             }
2135             handleresps();
2136         }
2137         return(TRUE);
2138     }
2139     return(FALSE);
2140 }
2141
2142 void cb_main_srchres_activate(GtkWidget *widget, GtkTreePath *path, GtkTreeViewColumn *col, gpointer data)
2143 {
2144     int tag;
2145     struct dc_response *resp;
2146     GtkTreeIter iter;
2147     GtkTreeModel *model;
2148     int size, num;
2149     char *tfnet, *tpeerid, *tfilename, *thash, *arg;
2150     wchar_t *fnet, *peerid, *filename, *hash;
2151
2152     if(dcfd < 0)
2153     {
2154         msgbox(GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, _("Not connected to DC server"));
2155         return;
2156     }
2157     model = gtk_tree_view_get_model(GTK_TREE_VIEW(widget));
2158     if(!gtk_tree_model_get_iter(GTK_TREE_MODEL(model), &iter, path))
2159         return;
2160     gtk_tree_model_get(model, &iter, 7, &num, -1);
2161     if(num > 0)
2162         return;
2163     gtk_tree_model_get(GTK_TREE_MODEL(model), &iter, 0, &tfnet, 1, &tpeerid, 3, &tfilename, 4, &size, 9, &thash, -1);
2164     fnet = icmbstowcs(tfnet, "UTF-8");
2165     peerid = icmbstowcs(tpeerid, "UTF-8");
2166     filename = icmbstowcs(tfilename, "UTF-8");
2167     hash = (thash == NULL)?NULL:icmbstowcs(thash, "UTF-8");
2168     if((fnet == NULL) || (peerid == NULL) || (filename == NULL))
2169     {
2170         if(fnet != NULL)
2171             free(fnet);
2172         if(peerid != NULL)
2173             free(peerid);
2174         if(filename != NULL)
2175             free(filename);
2176         if(hash != NULL)
2177             free(hash);
2178         g_free(tfnet);
2179         g_free(tpeerid);
2180         g_free(tfilename);
2181         if(thash != NULL)
2182             g_free(thash);
2183         return;
2184     }
2185     g_free(tfnet);
2186     g_free(tpeerid);
2187     g_free(tfilename);
2188     arg = (char *)gtk_entry_get_text(GTK_ENTRY(main_dlarg));
2189     if(*arg)
2190         tag = dc_queuecmd(NULL, NULL, L"download", fnet, L"%ls", peerid, L"%ls", filename, L"%i", size, L"hash", L"%ls", (hash == NULL)?L"":hash, L"user", L"%s", arg, NULL);
2191     else
2192         tag = dc_queuecmd(NULL, NULL, L"download", fnet, L"%ls", peerid, L"%ls", filename, L"%i", size, L"hash", L"%ls", (hash == NULL)?L"":hash, NULL);
2193     free(fnet);
2194     free(peerid);
2195     free(filename);
2196     if(hash != NULL)
2197         free(hash);
2198     if((resp = dc_gettaggedrespsync(tag)) != NULL)
2199     {
2200         if(resp->code == 502)
2201             msgbox(GTK_MESSAGE_WARNING, GTK_BUTTONS_OK, _("You do not have permission to do that"));
2202         if(resp->code != 200)
2203             msgbox(GTK_MESSAGE_WARNING, GTK_BUTTONS_OK, _("An error occurred while trying to queue the download (%i)"), resp->code);
2204         dc_freeresp(resp);
2205     }
2206     handleresps();
2207 }
2208
2209 gboolean srchfilterfunc(GtkTreeModel *model, GtkTreeIter *iter, gpointer data)
2210 {
2211     int slots;
2212     int filteratall;
2213
2214     filteratall = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(main_filternoslots));
2215     if(!filteratall)
2216         return(TRUE);
2217     gtk_tree_model_get(model, iter, 5, &slots, -1);
2218     if(slots < 1)
2219         return(FALSE);
2220     return(TRUE);
2221 }
2222
2223 void cb_main_filternoslots_toggled(GtkToggleButton *widget, gpointer data)
2224 {
2225     gtk_tree_model_filter_refilter(srchmodelfilter);
2226 }
2227
2228 void cb_main_srhash_activate(GtkWidget *widget, gpointer data)
2229 {
2230     GtkTreeSelection *sel;
2231     GtkTreeModel *model;
2232     GtkTreeIter iter;
2233     char *hash, *buf;
2234
2235     if(nextsrch != -1)
2236         return;
2237     sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(main_srchres));
2238     if(gtk_tree_selection_get_selected(sel, &model, &iter))
2239     {
2240         gtk_tree_model_get(model, &iter, 9, &hash, -1);
2241         buf = sprintf2("H=%s", hash);
2242         gtk_entry_set_text(GTK_ENTRY(main_realsrch), buf);
2243         g_free(hash);
2244         free(buf);
2245         cb_main_srchbtn_clicked(widget, NULL);
2246     } else {
2247         return;
2248     }
2249 }
2250
2251 void cb_main_srcopy_activate(GtkWidget *widget, gpointer data)
2252 {
2253     GtkClipboard *cb;
2254     GtkTreeSelection *sel;
2255     GtkTreeModel *model;
2256     GtkTreeIter iter;
2257     char *hash;
2258
2259     if(nextsrch != -1)
2260         return;
2261     sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(main_srchres));
2262     if(!gtk_tree_selection_get_selected(sel, &model, &iter))
2263         return;
2264     gtk_tree_model_get(model, &iter, 9, &hash, -1);
2265     cb = gtk_clipboard_get(gdk_atom_intern("PRIMARY", FALSE));
2266     gtk_clipboard_set_text(cb, hash, -1);
2267     g_free(hash);
2268 }
2269
2270 void cb_main_trhash_activate(GtkWidget *widget, gpointer data)
2271 {
2272     GtkTreeSelection *sel;
2273     GtkTreeModel *model;
2274     GtkTreeIter iter;
2275     char *hash, *buf;
2276
2277     if(nextsrch != -1)
2278         return;
2279     sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(main_downloads));
2280     if(gtk_tree_selection_get_selected(sel, &model, &iter))
2281     {
2282         gtk_tree_model_get(model, &iter, 12, &hash, -1);
2283         buf = sprintf2("H=%s", hash);
2284         gtk_entry_set_text(GTK_ENTRY(main_realsrch), buf);
2285         g_free(hash);
2286         free(buf);
2287         cb_main_srchbtn_clicked(widget, NULL);
2288     } else {
2289         return;
2290     }
2291 }
2292
2293 void cb_main_trcopy_activate(GtkWidget *widget, gpointer data)
2294 {
2295     GtkClipboard *cb;
2296     GtkTreeSelection *sel;
2297     GtkTreeModel *model;
2298     GtkTreeIter iter;
2299     char *hash;
2300
2301     sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(main_downloads));
2302     if(!gtk_tree_selection_get_selected(sel, &model, &iter))
2303         return;
2304     gtk_tree_model_get(model, &iter, 12, &hash, -1);
2305     cb = gtk_clipboard_get(gdk_atom_intern("PRIMARY", FALSE));
2306     gtk_clipboard_set_text(cb, hash, -1);
2307     g_free(hash);
2308 }
2309
2310 void cb_main_trreset_activate(GtkWidget *widget, gpointer data)
2311 {
2312     GtkTreeSelection *sel;
2313     GtkTreeModel *model;
2314     GtkTreeIter iter;
2315     int id, tag;
2316     struct dc_response *resp;
2317
2318     sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(main_downloads));
2319     if(gtk_tree_selection_get_selected(sel, &model, &iter))
2320     {
2321         gtk_tree_model_get(model, &iter, 0, &id, -1);
2322         tag = dc_queuecmd(NULL, NULL, L"reset", L"%i", id, NULL);
2323         if((resp = dc_gettaggedrespsync(tag)) != NULL)
2324         {
2325             if(resp->code == 502)
2326                 msgbox(GTK_MESSAGE_WARNING, GTK_BUTTONS_OK, _("You do not have permission to do that"));
2327             else if(resp->code != 200)
2328                 msgbox(GTK_MESSAGE_WARNING, GTK_BUTTONS_OK, _("An error occurred while trying to reset (%i)"), resp->code);
2329             dc_freeresp(resp);
2330         }
2331         handleresps();
2332     } else {
2333         return;
2334     }
2335 }
2336
2337 void cb_main_trcancel_activate(GtkWidget *widget, gpointer data)
2338 {
2339     GtkTreeSelection *sel;
2340     GtkTreeModel *model;
2341     GtkTreeIter iter;
2342     int id, tag;
2343     struct dc_response *resp;
2344
2345     sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(main_downloads));
2346     if(gtk_tree_selection_get_selected(sel, &model, &iter))
2347     {
2348         gtk_tree_model_get(model, &iter, 0, &id, -1);
2349         tag = dc_queuecmd(NULL, NULL, L"cancel", L"%i", id, NULL);
2350         if((resp = dc_gettaggedrespsync(tag)) != NULL)
2351         {
2352             if(resp->code == 502)
2353                 msgbox(GTK_MESSAGE_WARNING, GTK_BUTTONS_OK, _("You do not have permission to do that"));
2354             else if(resp->code != 200)
2355                 msgbox(GTK_MESSAGE_WARNING, GTK_BUTTONS_OK, _("An error occurred while trying to cancel (%i)"), resp->code);
2356             dc_freeresp(resp);
2357         }
2358         handleresps();
2359     } else {
2360         return;
2361     }
2362 }
2363
2364 /* XXX: This is quite a hack, since the calling convention is
2365  * different for the popup-menu sig and the button-press-event sig. It
2366  * most certainly works, but I don't know how portable it is. */
2367 gboolean cb_main_srpopup(GtkWidget *widget, GdkEventButton *event, gpointer data)
2368 {
2369     GtkTreeSelection *sel;
2370     GtkTreeModel *model;
2371     GtkTreeIter iter;
2372     char *hash;
2373
2374     if((event != NULL) && (event->button != 3))
2375         return(FALSE);
2376     sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(widget));
2377     if(gtk_tree_selection_get_selected(sel, &model, &iter))
2378     {
2379         gtk_tree_model_get(model, &iter, 9, &hash, -1);
2380         if((hash == NULL) || (*hash == 0))
2381         {
2382             gtk_widget_set_sensitive(main_srhash, FALSE);
2383             gtk_widget_set_sensitive(main_srcopy, FALSE);
2384         } else {
2385             if(nextsrch == -1)
2386                 gtk_widget_set_sensitive(main_srhash, TRUE);
2387             else
2388                 gtk_widget_set_sensitive(main_srhash, FALSE);
2389             gtk_widget_set_sensitive(main_srcopy, TRUE);
2390         }
2391         g_free(hash);
2392     } else {
2393         return(FALSE);
2394     }
2395     if(event == NULL)
2396         gtk_menu_popup(GTK_MENU(main_srpopup), NULL, NULL, NULL, NULL, 0, gtk_get_current_event_time());
2397     else
2398         gtk_menu_popup(GTK_MENU(main_srpopup), NULL, NULL, NULL, NULL, event->button, event->time);
2399     return(FALSE);
2400 }
2401
2402 /* The above hack note goes for this one too. */
2403 gboolean cb_main_trpopup(GtkWidget *widget, GdkEventButton *event, gpointer data)
2404 {
2405     GtkTreeSelection *sel;
2406     GtkTreeModel *model;
2407     GtkTreeIter iter;
2408     char *hash;
2409
2410     if((event != NULL) && (event->button != 3))
2411         return(FALSE);
2412     sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(widget));
2413     if(gtk_tree_selection_get_selected(sel, &model, &iter))
2414     {
2415         gtk_tree_model_get(model, &iter, 12, &hash, -1);
2416         if((hash == NULL) || (*hash == 0))
2417         {
2418             gtk_widget_set_sensitive(main_trhash, FALSE);
2419             gtk_widget_set_sensitive(main_trcopy, FALSE);
2420         } else {
2421             if(nextsrch == -1)
2422                 gtk_widget_set_sensitive(main_trhash, TRUE);
2423             else
2424                 gtk_widget_set_sensitive(main_trhash, FALSE);
2425             gtk_widget_set_sensitive(main_trcopy, TRUE);
2426         }
2427         g_free(hash);
2428     } else {
2429         return(FALSE);
2430     }
2431     if(event == NULL)
2432         gtk_menu_popup(GTK_MENU(main_trpopup), NULL, NULL, NULL, NULL, 0, gtk_get_current_event_time());
2433     else
2434         gtk_menu_popup(GTK_MENU(main_trpopup), NULL, NULL, NULL, NULL, event->button, event->time);
2435     return(FALSE);
2436 }
2437
2438 void cb_reslist_reload_clicked(GtkWidget *widget, gpointer data)
2439 {
2440     if(lsrestag != -1)
2441         return;
2442     gtk_widget_set_sensitive(reslist_delete, FALSE);
2443     gtk_widget_set_sensitive(reslist_search, FALSE);
2444     gtk_list_store_clear(reslist);
2445     lsrestag = dc_queuecmd(NULL, NULL, L"filtercmd", L"lsres", NULL);
2446     gtk_widget_set_sensitive(reslist_reload, FALSE);
2447 }
2448
2449 int rmres(char *id)
2450 {
2451     int tag, ret;
2452     struct dc_response *resp;
2453
2454     ret = -1;
2455     tag = dc_queuecmd(NULL, NULL, L"filtercmd", L"rmres", L"%s", id, NULL);
2456     if((resp = dc_gettaggedrespsync(tag)) != NULL)
2457     {
2458         if(resp->numlines > 0)
2459         {
2460             if(!wcscmp(resp->rlines[0].argv[1], L"ok"))
2461                 ret = 0;
2462             else if(!wcsncmp(resp->rlines[0].argv[1], L"err:", 4))
2463                 msgbox(GTK_MESSAGE_WARNING, GTK_BUTTONS_OK, _("An error occurred (%ls)"), resp->rlines[0].argv[1] + 4);
2464         }
2465         dc_freeresp(resp);
2466     }
2467     handleresps();
2468     return(ret);
2469 }
2470
2471 void cb_reslist_delete_clicked(GtkWidget *widget, gpointer data)
2472 {
2473     GtkTreeIter iter;
2474     GtkTreeModel *model;
2475     char *id;
2476     gboolean locked;
2477
2478     if(nextsrch != -1)
2479         return;
2480     if(!gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(reslist_list)), &model, &iter))
2481         return;
2482     gtk_tree_model_get(GTK_TREE_MODEL(model), &iter, 0, &id, 4, &locked, -1);
2483     if(locked)
2484     {
2485         g_free(id);
2486         return;
2487     }
2488     if(!rmres(id))
2489         gtk_list_store_remove(GTK_LIST_STORE(model), &iter);
2490     g_free(id);
2491 }
2492
2493 void cb_reslist_search_clicked(GtkWidget *widget, gpointer data)
2494 {
2495     GtkTreeIter iter;
2496     GtkTreeModel *model;
2497     char *hash, *buf;
2498
2499     if(nextsrch != -1)
2500         return;
2501     if(!gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(reslist_list)), &model, &iter))
2502         return;
2503     gtk_tree_model_get(GTK_TREE_MODEL(model), &iter, 5, &hash, -1);
2504     buf = sprintf2("H=%s", hash);
2505     gtk_entry_set_text(GTK_ENTRY(main_realsrch), buf);
2506     free(buf);
2507     g_free(hash);
2508     cb_main_srchbtn_clicked(widget, NULL);
2509 }
2510
2511 void cb_reslist_list_cchange(GtkWidget *widget, gpointer data)
2512 {
2513     GtkTreeIter iter;
2514     GtkTreeModel *model;
2515     gboolean locked;
2516     char *hash;
2517
2518     if(!gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(reslist_list)), &model, &iter))
2519     {
2520         gtk_widget_set_sensitive(reslist_delete, FALSE);
2521         gtk_widget_set_sensitive(reslist_search, FALSE);
2522         return;
2523     }
2524     gtk_tree_model_get(GTK_TREE_MODEL(model), &iter, 4, &locked, 5, &hash, -1);
2525     gtk_widget_set_sensitive(reslist_delete, !locked);
2526     gtk_widget_set_sensitive(reslist_search, hash && *hash);
2527     g_free(hash);
2528 }
2529
2530 void cb_reslist_list_activate(GtkWidget *widget, GtkTreePath *path, GtkTreeViewColumn *col, gpointer data)
2531 {
2532     GtkTreeIter iter;
2533     GtkTreeModel *model;
2534     char *hash, *buf;
2535
2536     model = gtk_tree_view_get_model(GTK_TREE_VIEW(widget));
2537     if(!gtk_tree_model_get_iter(GTK_TREE_MODEL(model), &iter, path))
2538         return;
2539     if(nextsrch != -1)
2540         return;
2541     gtk_tree_model_get(model, &iter, 5, &hash, -1);
2542     buf = sprintf2("H=%s", hash);
2543     gtk_entry_set_text(GTK_ENTRY(main_realsrch), buf);
2544     free(buf);
2545     g_free(hash);
2546     cb_main_srchbtn_clicked(widget, NULL);
2547 }
2548
2549 gboolean cb_reslist_list_keypress(GtkWidget *widget, GdkEventKey *event, gpointer data)
2550 {
2551     GtkTreeSelection *sel;
2552     GtkTreeModel *model;
2553     GtkTreeIter iter;
2554     char *id;
2555     gboolean locked;
2556
2557     if((event->type == GDK_KEY_PRESS) && (event->keyval == GDK_Delete))
2558     {
2559         sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(widget));
2560         if(gtk_tree_selection_get_selected(sel, &model, &iter))
2561         {
2562             gtk_tree_model_get(model, &iter, 0, &id, 4, &locked, -1);
2563             if(!locked)
2564             {
2565                 if(!rmres(id))
2566                     gtk_list_store_remove(GTK_LIST_STORE(model), &iter);
2567             }
2568             g_free(id);
2569         }
2570         return(TRUE);
2571     }
2572     return(FALSE);
2573 }
2574
2575 void srchstatupdate(void)
2576 {
2577     char buf[1024];
2578
2579     if(nextsrch == -1)
2580     {
2581         snprintf(buf, 1024, _("Ready to search"));
2582     } else {
2583         snprintf(buf, 1024, _("Search scheduled and will be submitted in %i seconds"), (int)(srcheta - time(NULL)));
2584     }
2585     if(strcmp(gtk_label_get_text(GTK_LABEL(main_srchstatus)), buf))
2586         gtk_label_set_text(GTK_LABEL(main_srchstatus), buf);
2587 }
2588
2589 gint srchstatupdatecb(gpointer data)
2590 {
2591     srchstatupdate();
2592     return(TRUE);
2593 }
2594
2595 void initchattags(void)
2596 {
2597     GtkTextTag *tag;
2598
2599     chattags = gtk_text_tag_table_new();
2600     tag = gtk_text_tag_new("sender");
2601     g_object_set(tag, "foreground", "blue", NULL);
2602     gtk_text_tag_table_add(chattags, tag);
2603 }
2604
2605 int main(int argc, char **argv)
2606 {
2607     GtkWidget *wnd;
2608     PangoFontDescription *monospacefont;
2609     GtkTreeModel *sortmodel;
2610     struct passwd *pwent;
2611
2612     setlocale(LC_ALL, "");
2613     bindtextdomain(PACKAGE, LOCALEDIR);
2614     textdomain(PACKAGE);
2615     gtk_init(&argc, &argv);
2616     dc_init();
2617     signal(SIGCHLD, SIG_IGN);
2618     pubhubaddr = sstrdup("http://www.hublist.org/PublicHubList.xml.bz2");
2619     dcserver = sstrdup("");
2620     if((pwent = getpwuid(getuid())) == NULL)
2621     {
2622         fprintf(stderr, "could not get your passwd data");
2623         exit(1);
2624     }
2625     connectas = sstrdup(pwent->pw_name);
2626     wnd = create_main_wnd();
2627     create_reslist_wnd();
2628     gtk_window_resize(GTK_WINDOW(reslist_wnd), 600, 400);
2629     initchattags();
2630
2631     fnmodel = gtk_list_store_new(6, G_TYPE_INT, G_TYPE_STRING, G_TYPE_INT, G_TYPE_INT, G_TYPE_STRING, G_TYPE_STRING);
2632     gtk_tree_view_set_model(GTK_TREE_VIEW(main_fnetnodes), GTK_TREE_MODEL(fnmodel));
2633     gtk_tree_view_set_model(GTK_TREE_VIEW(main_chatnodes), GTK_TREE_MODEL(fnmodel));
2634
2635     reslist = gtk_list_store_new(6, G_TYPE_STRING, G_TYPE_INT, G_TYPE_INT, G_TYPE_STRING, G_TYPE_BOOLEAN, G_TYPE_STRING);
2636     gtk_tree_view_set_model(GTK_TREE_VIEW(reslist_list), GTK_TREE_MODEL(reslist));
2637
2638     dlmodel = gtk_list_store_new(13, G_TYPE_INT, /* id */
2639                                  G_TYPE_INT,     /* dir */
2640                                  G_TYPE_INT,     /* state */
2641                                  G_TYPE_STRING,  /* peerid */
2642                                  G_TYPE_STRING,  /* peernick */
2643                                  G_TYPE_STRING,  /* path */
2644                                  G_TYPE_INT,     /* size */
2645                                  G_TYPE_INT,     /* curpos */
2646                                  G_TYPE_STRING,  /* stock */
2647                                  G_TYPE_FLOAT,   /* percentage */
2648                                  G_TYPE_INT,     /* error */
2649                                  G_TYPE_INT,     /* errortime */
2650                                  G_TYPE_STRING); /* hash */
2651     gtk_tree_view_set_model(GTK_TREE_VIEW(main_downloads), GTK_TREE_MODEL(dlmodel));
2652
2653     ulmodel = gtk_list_store_new(13, G_TYPE_INT, G_TYPE_INT, G_TYPE_INT, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT, G_TYPE_INT, G_TYPE_STRING, G_TYPE_FLOAT, G_TYPE_INT, G_TYPE_INT, G_TYPE_STRING);
2654     gtk_tree_view_set_model(GTK_TREE_VIEW(main_uploads), GTK_TREE_MODEL(ulmodel));
2655
2656     srchmodel = gtk_tree_store_new(10, G_TYPE_STRING, /* fnetname */
2657                                    G_TYPE_STRING,     /* peerid */
2658                                    G_TYPE_STRING,     /* peername */
2659                                    G_TYPE_STRING,     /* filename */
2660                                    G_TYPE_INT,        /* size */
2661                                    G_TYPE_INT,        /* slots */
2662                                    G_TYPE_DOUBLE,     /* resptime */
2663                                    G_TYPE_INT,        /* sizenum */
2664                                    G_TYPE_INT,        /* speed */
2665                                    G_TYPE_STRING);    /* hash */
2666     srchmodelfilter = GTK_TREE_MODEL_FILTER(gtk_tree_model_filter_new(GTK_TREE_MODEL(srchmodel), NULL));
2667     gtk_tree_model_filter_set_visible_func(srchmodelfilter, srchfilterfunc, NULL, NULL);
2668     sortmodel = gtk_tree_model_sort_new_with_model(GTK_TREE_MODEL(srchmodelfilter));
2669     gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(sortmodel), 4, GTK_SORT_DESCENDING);
2670     gtk_tree_view_set_model(GTK_TREE_VIEW(main_srchres), GTK_TREE_MODEL(sortmodel));
2671     g_object_unref(sortmodel);
2672
2673     monospacefont = pango_font_description_from_string("Monospace 10");
2674     gtk_widget_modify_font(main_chatview, monospacefont);
2675     pango_font_description_free(monospacefont);
2676     readconfigfile();
2677     updatesbar(_("Disconnected"));
2678     gtk_widget_show(wnd);
2679     if(autoconn)
2680         dcconnect(dcserver);
2681     g_timeout_add(500, srchstatupdatecb, NULL);
2682     g_timeout_add(5000, ksupdatecb, NULL);
2683     g_timeout_add(1000, updatetransfers, NULL);
2684     gtk_main();
2685     return(0);
2686 }