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