daemon/fnet-dc.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 #include <stdlib.h>
  20 #include <stdio.h>
  21 #include <wchar.h>
  22 #include <unistd.h>
  23 #include <fcntl.h>
  24 #include <string.h>
  25 #include <netinet/in.h>
  26 #include <arpa/inet.h>
  27 #include <wctype.h>
  28 #include <time.h>
  29 #include <errno.h>
  30 #include <bzlib.h>
  31 #include <zlib.h>
  32 #include <sys/stat.h>
  33
  34 #ifdef HAVE_CONFIG_H
  35 #include <config.h>
  36 #endif
  37 #include "filenet.h"
  38 #include "log.h"
  39 #include "module.h"
  40 #include "utils.h"
  41 #include "client.h"
  42 #include "transfer.h"
  43 #include "sysevents.h"
  44 #include "net.h"
  45 #include <tiger.h>
  46
  47 /*
  48  * The Direct Connect protocol is extremely ugly. Thus, this code must
  49  * also be a bit ugly in certain places. Please forgive me. =/
  50  *
  51  * This also means that there might be some pieces of the code that
  52  * look completely illogical to you, and you think that you may make
  53  * them much neater/better. However, in many cases it might just be
  54  * that it's required to cope with some oddity of the protocol, such
  55  * as the amazingly ugly delayed key response in the peer protocol.
  56  */
  57
  58 /* I assume this is the correct character set to use for DC,
  59  * considering it was developed without i18n support under Windows */
  60 #define DCCHARSET "windows-1252"
  61
  62 #ifdef DCPP_MASQUERADE
  63 /*
  64  * I honestly don't want to pretend being a client that I'm not, but
  65  * there are so many hubs that simply do not accept any clients
  66  * outside their whitelists, for no obvious reasons, so I feel that I
  67  * am left with little choice. Anyhow, as long as I actually support
  68  * all the features that my faked DC++ version does, there should be
  69  * very little harm done.
  70  */
  71 #define DCIDTAG "++"
  72 #define DCIDTAGV "0.674"
  73 #define DCIDFULL "DC++ 0.674"
  74 #else
  75 #define DCIDTAG "Dolda"
  76 #define DCIDTAGV VERSION
  77 #define DCIDFULL "DoldaConnect " VERSION
  78 #endif
  79
  80 #define PEER_CMD 0
  81 #define PEER_STOP 1
  82 #define PEER_TRNS 2
  83 #define PEER_SYNC 3
  84 #define PEER_TTHL 4
  85
  86 #define CPRS_NONE 0
  87 #define CPRS_ZLIB 1
  88
  89 struct command
  90 {
  91     char *name;
  92     void (*handler)(struct socket *sk, void *data, char *cmd, char *args);
  93     int stop;
  94 };
  95
  96 struct qcommand
  97 {
  98     struct qcommand *next;
  99     char *string;
 100 };
 101
 102 struct dchub
 103 {
 104     struct socket *sk;
 105     char *inbuf;
 106     size_t inbufdata, inbufsize;
 107     struct qcommand *queue;
 108     int extended, dcppemu;
 109     char *charset;
 110     char *nativename;
 111     char *nativenick;
 112     char **supports;
 113 };
 114
 115 struct dcexppeer
 116 {
 117     struct dcexppeer *next, *prev;
 118     char *nick;
 119     struct fnetnode *fn;
 120     struct timer *expire;
 121 };
 122
 123 struct dcpeer
 124 {
 125     struct dcpeer *next, *prev;
 126     struct socket *sk;
 127     struct fnetnode *fn;
 128     char *inbuf;
 129     size_t inbufdata, inbufsize;
 130     size_t curread, totalsize;
 131     int freeing;
 132     struct timer *timeout;
 133     struct qcommand *queue;
 134     struct transfer *transfer;
 135     int state;
 136     int ptclose;      /* Close after transfer is complete */
 137     int accepted;     /* If false, we connected, otherwise, we accepted */
 138     int extended, dcppemu;
 139     int direction;    /* Using the constants from transfer.h */
 140     int compress;
 141     int hascurpos, fetchingtthl, notthl;
 142     struct tigertreehash tth;
 143     char *charset;
 144     void *cprsdata;
 145     char *key;
 146     char *nativename;
 147     char **supports;
 148     wchar_t *wcsname;
 149 };
 150
 151 static struct fnet dcnet;
 152 static struct transferiface dctransfer;
 153 static struct socket *udpsock = NULL;
 154 static struct socket *tcpsock = NULL;
 155 static struct dcpeer *peers = NULL;
 156 int numdcpeers = 0;
 157 static struct dcexppeer *expected = NULL;
 158 static char *hmlistname = NULL;
 159 static char *xmllistname = NULL;
 160 static char *xmlbz2listname = NULL;
 161 static struct timer *listwritetimer = NULL;
 162
 163 static void peerconnect(struct socket *sk, int err, struct fnetnode *fn);
 164 static void freedcpeer(struct dcpeer *peer);
 165 static void transread(struct socket *sk, struct dcpeer *peer);
 166 static void transerr(struct socket *sk, int err, struct dcpeer *peer);
 167 static void transwrite(struct socket *sk, struct dcpeer *peer);
 168 static void updatehmlist(void);
 169 static void updatexmllist(void);
 170 static void updatexmlbz2list(void);
 171 static void requestfile(struct dcpeer *peer);
 172 static void updatelists(int now);
 173
 174 static int reservedchar(unsigned char c)
 175 {
 176     return((c == 0) || (c == 5) || (c == 124) || (c == 96) || (c == 126) || (c == 36));
 177 }
 178
 179 /* Oh, how I despise having to do this... */
 180 static char *dcmakekey(char *lock)
 181 {
 182     int i, len, offset;
 183     char *buf, *key;
 184     char save;
 185
 186     buf = smalloc(strlen(lock));
 187     save = 5;
 188     len = 0;
 189     for(i = 0; lock[i]; i++)
 190     {
 191         buf[i] = lock[i] ^ save;
 192         buf[i] = ((buf[i] & 0x0F) << 4) | ((buf[i] & 0xF0) >> 4);
 193         save = lock[i];
 194         if((i != 0) && reservedchar(buf[i]))
 195             len += 10;
 196         else
 197             len++;
 198     }
 199     buf[0] ^= buf[i - 1];
 200     if(reservedchar(buf[0]))
 201         len += 10;
 202     else
 203         len++;
 204     key = smalloc(len + 1);
 205     offset = 0;
 206     for(i = 0; lock[i] != 0; i++)
 207     {
 208         if(reservedchar(buf[i]))
 209             offset += sprintf(key + offset, "/%%DCN%03i%%/", buf[i]);
 210         else
 211             key[offset++] = buf[i];
 212     }
 213     key[offset] = 0;
 214     free(buf);
 215     return(key);
 216 }
 217
 218 static char *pathnmdc2adc(char *path)
 219 {
 220     char *ret;
 221     size_t retsize, retdata;
 222
 223     if(!strcmp(path, "files.xml") || !strcmp(path, "files.xml.bz2") || !strcmp(path, "MyList.DcLst"))
 224         return(sstrdup(path));
 225     ret = NULL;
 226     retsize = retdata = 0;
 227     addtobuf(ret, '/');
 228     for(; *path; path++)
 229     {
 230         if(*path == '\\')
 231             addtobuf(ret, '/');
 232         else
 233             addtobuf(ret, *path);
 234     }
 235     addtobuf(ret, 0);
 236     return(ret);
 237 }
 238
 239 static int isdchash(struct hash *hash)
 240 {
 241     if(wcscmp(hash->algo, L"TTH"))
 242         return(0);
 243     if(hash->len != 24)
 244         return(0);
 245     return(1);
 246 }
 247
 248 /*
 249  * Uncomment when used!
 250
 251 static int hubsupports(struct dchub *hub, char *cap)
 252 {
 253     char **p;
 254
 255     if(hub->supports == NULL)
 256         return(0);
 257     for(p = hub->supports; *p != NULL; p++)
 258     {
 259         if(!strcasecmp(*p, cap))
 260             return(1);
 261     }
 262     return(0);
 263 }
 264 */
 265
 266 static int supports(struct dcpeer *peer, char *cap)
 267 {
 268     char **p;
 269
 270     if(peer->supports == NULL)
 271         return(0);
 272     for(p = peer->supports; *p != NULL; p++)
 273     {
 274         if(!strcasecmp(*p, cap))
 275             return(1);
 276     }
 277     return(0);
 278 }
 279
 280 static void endcompress(struct dcpeer *peer)
 281 {
 282     if(peer->compress == CPRS_ZLIB)
 283     {
 284         deflateEnd(peer->cprsdata);
 285         free(peer->cprsdata);
 286     }
 287     peer->compress = CPRS_NONE;
 288 }
 289
 290 static void initcompress(struct dcpeer *peer, int algo)
 291 {
 292     int ret;
 293
 294     endcompress(peer);
 295     peer->compress = algo;
 296     if(algo == CPRS_ZLIB)
 297     {
 298         peer->cprsdata = smalloc(sizeof(z_stream));
 299         memset(peer->cprsdata, 0, sizeof(z_stream));
 300         if((ret = deflateInit(peer->cprsdata, 3)) != Z_OK)
 301         {
 302             flog(LOG_CRIT, "Aiya! zlib refuses to init (%i)!", ret);
 303             abort();
 304         }
 305     }
 306 }
 307
 308 static void unquote(wchar_t *in)
 309 {
 310     wchar_t *p, *p2, nc;
 311
 312     for(p = in; *p != L'\0'; p++)
 313     {
 314         if(*p == L'&')
 315         {
 316             for(p2 = p + 1; (*p2 != L'\0') && (*p2 != L';') && (*p2 != L'&'); p2++);
 317             if(*p2 == L'&')
 318                 continue;
 319             if(*p2 == L'\0')
 320                 return;
 321             *p2 = L'\0';
 322             nc = L'\0';
 323             if(!wcscmp(p + 1, L"amp"))
 324             {
 325                 nc = L'&';
 326             } else if(p[1] == L'#') {
 327                 nc = ucptowc(wcstol(p + 2, NULL, 10));
 328             }
 329             if(nc == L'\0')
 330             {
 331                 *p2 = L';';
 332                 p = p2;
 333                 continue;
 334             }
 335             *p = nc;
 336             memmove(p + 1, p2 + 1, (wcslen(p2 + 1) + 1) * sizeof(wchar_t));
 337         }
 338     }
 339 }
 340
 341 static void freeexppeer(struct dcexppeer *ep)
 342 {
 343     if(ep->next != NULL)
 344         ep->next->prev = ep->prev;
 345     if(ep->prev != NULL)
 346         ep->prev->next = ep->next;
 347     if(ep == expected)
 348         expected = ep->next;
 349     free(ep->nick);
 350     putfnetnode(ep->fn);
 351     if(ep->expire != NULL)
 352         canceltimer(ep->expire);
 353     free(ep);
 354 }
 355
 356 static void exppeerexpire(int cancelled, struct dcexppeer *ep)
 357 {
 358     ep->expire = NULL;
 359     if(!cancelled)
 360         freeexppeer(ep);
 361 }
 362
 363 static struct dcexppeer *expectpeer(char *nick, struct fnetnode *fn)
 364 {
 365     struct dcexppeer *ep;
 366
 367     ep = smalloc(sizeof(*ep));
 368     ep->nick = sstrdup(nick);
 369     getfnetnode(ep->fn = fn);
 370     ep->expire = timercallback(ntime() + 300, (void (*)(int, void *))exppeerexpire, ep);
 371     ep->next = expected;
 372     ep->prev = NULL;
 373     if(expected != NULL)
 374         expected->prev = ep;
 375     expected = ep;
 376     return(ep);
 377 }
 378
 379 static struct qcommand *newqcmd(struct qcommand **queue, char *string)
 380 {
 381     struct qcommand *new;
 382
 383     while(*queue != NULL)
 384         queue = &(*queue)->next;
 385     new = smalloc(sizeof(*new));
 386     new->string = sstrdup(string);
 387     new->next = *queue;
 388     *queue = new;
 389     return(new);
 390 }
 391
 392 static struct qcommand *ulqcmd(struct qcommand **queue)
 393 {
 394     struct qcommand *qcmd;
 395
 396     if((qcmd = *queue) == NULL)
 397         return(NULL);
 398     *queue = qcmd->next;
 399     return(qcmd);
 400 }
 401
 402 static void freeqcmd(struct qcommand *qcmd)
 403 {
 404     free(qcmd->string);
 405     free(qcmd);
 406 }
 407
 408 static void hubrecvchat(struct socket *sk, struct fnetnode *fn, char *from, char *string)
 409 {
 410     wchar_t *chat, *wfrom, *wpeer;
 411     char *p, *end;
 412     struct fnetpeer *peer;
 413     struct dchub *hub;
 414
 415     hub = fn->data;
 416     end = string + strlen(string);
 417     while((p = strchr(string, 13)) != NULL)
 418         memmove(p, p + 1, (end-- - p));
 419     if(from != NULL)
 420     {
 421         if((strlen(string) > strlen(from) + 2) && (*string == '<') && !memcmp(string + 1, from, strlen(from)) && (*(string + strlen(from) + 1) == '>'))
 422             string += strlen(from) + 2;
 423         if((wfrom = icmbstowcs(from, hub->charset)) == NULL)
 424             return;
 425         wpeer = swcsdup(wfrom);
 426     } else {
 427         wfrom = NULL;
 428         wpeer = NULL;
 429         if(*string == '<')
 430         {
 431             for(p = string + 1; *p; p++)
 432             {
 433                 if((*p == ' ') || (*p == '>'))
 434                     break;
 435             }
 436             if(*p == '>')
 437             {
 438                 *(p++) = 0;
 439                 if(*p == ' ')
 440                     p++;
 441                 if((wpeer = icmbstowcs(string + 1, hub->charset)) == NULL)
 442                     return;
 443                 string = p;
 444             }
 445         }
 446         if(wpeer == NULL)
 447             wpeer = swcsdup(L"");
 448     }
 449     if((chat = icmbstowcs(string, hub->charset)) == NULL)
 450     {
 451         if(wfrom != NULL)
 452             free(wfrom);
 453         free(wpeer);
 454         return;
 455     }
 456     unquote(chat);
 457     if(wfrom != NULL)
 458     {
 459         if((peer = fnetfindpeer(fn, wfrom)) == NULL) /* Assume public chat */
 460             fnethandlechat(fn, 1, wfrom, wpeer, chat);
 461         else
 462             fnethandlechat(fn, 0, wfrom, wpeer, chat);
 463     } else {
 464         fnethandlechat(fn, 1, L"", wpeer, chat);
 465     }
 466     if(wfrom != NULL)
 467         free(wfrom);
 468     free(wpeer);
 469     free(chat);
 470 }
 471
 472 static void peertimeout(int cancelled, struct dcpeer *peer)
 473 {
 474     peer->timeout = NULL;
 475     if(cancelled)
 476         return;
 477     freedcpeer(peer);
 478 }
 479
 480 static void sendadc(struct socket *sk, char *arg)
 481 {
 482     char *buf;
 483     size_t bufsize, bufdata;
 484
 485     buf = NULL;
 486     bufsize = bufdata = 0;
 487     addtobuf(buf, ' ');
 488     for(; *arg; arg++)
 489     {
 490         if(*arg == ' ')
 491         {
 492             bufcat(buf, "\\s", 2);
 493         } else if(*arg == '\n') {
 494             bufcat(buf, "\\n", 2);
 495         } else if(*arg == '\\') {
 496             bufcat(buf, "\\\\", 2);
 497         } else {
 498             addtobuf(buf, *arg);
 499         }
 500     }
 501     sockqueue(sk, buf, bufdata);
 502     free(buf);
 503 }
 504
 505 static void sendadcf(struct socket *sk, char *arg, ...)
 506 {
 507     char *buf;
 508     va_list args;
 509
 510     va_start(args, arg);
 511     buf = vsprintf2(arg, args);
 512     va_end(args);
 513     if(buf == NULL)
 514         return;
 515     sendadc(sk, buf);
 516     free(buf);
 517 }
 518
 519 static char **parseadc(char *args)
 520 {
 521     char **retbuf;
 522     size_t retbufsize, retbufdata;
 523     char *buf;
 524     size_t bufsize, bufdata;
 525     int state;
 526
 527     retbuf = NULL;
 528     buf = NULL;
 529     retbufsize = retbufdata = bufsize = bufdata = 0;
 530     state = 0;
 531     while(state != 3)
 532     {
 533         switch(state)
 534         {
 535         case 0:
 536             if(*args == 0)
 537                 state = 3;
 538             else if(*args != ' ')
 539                 state = 1;
 540             break;
 541         case 1:
 542             if((*args == ' ') || (*args == 0))
 543             {
 544                 addtobuf(buf, 0);
 545                 addtobuf(retbuf, buf);
 546                 buf = NULL;
 547                 bufsize = bufdata = 0;
 548                 if(*args == 0)
 549                     state = 3;
 550             } else if(*args == '\\') {
 551                 state = 2;
 552             } else {
 553                 addtobuf(buf, *args);
 554             }
 555             args++;
 556             break;
 557         case 2:
 558             if(*args == 0)
 559             {
 560                 if(buf != NULL)
 561                     free(buf);
 562                 addtobuf(retbuf, NULL);
 563                 freeparr(retbuf);
 564                 return(NULL);
 565             } else if((*args == 's') || (*args == ' ')) {
 566                 addtobuf(buf, ' ');
 567             } else if(*args == 'n') {
 568                 addtobuf(buf, '\n');
 569             } else if(*args == '\\') {
 570                 addtobuf(buf, '\\');
 571             }
 572             args++;
 573             state = 1;
 574             break;
 575         }
 576     }
 577     if(buf != NULL)
 578         free(buf);
 579     addtobuf(retbuf, NULL);
 580     return(retbuf);
 581 }
 582
 583 /* Macros useful in command handlers */
 584 #define skipspace(s) ({if(((s) = strchr((s), ' ')) == NULL) return; else (s)++;})
 585 #define qstr(sk, str) sockqueue(sk, str, strlen(str))
 586 #define qstrf(sk, strandargs...) \
 587 do { \
 588     char *__buf__; \
 589     if((__buf__ = sprintf2(strandargs)) != NULL) { \
 590         sockqueue(sk, __buf__, strlen(__buf__)); \
 591         free(__buf__); \
 592     } \
 593 } while(0)
 594
 595 static char *tr(char *str, char *trans)
 596 {
 597     char *p;
 598
 599     for(; *trans; trans += 2)
 600     {
 601         for(p = strchr(str, trans[0]); p != NULL; p = strchr(p, trans[0]))
 602             *p = trans[1];
 603     }
 604     return(str);
 605 }
 606
 607 static char *getadcid(struct dcpeer *peer)
 608 {
 609     char *buf;
 610     char *ret;
 611     int isfilelist;
 612
 613     isfilelist = 0;
 614     if(!wcscmp(peer->transfer->path, L"files.xml") || !wcscmp(peer->transfer->path, L"files.xml.bz2") || !wcscmp(peer->transfer->path, L"MyList.DcLst"))
 615         isfilelist = 1;
 616     if(!isfilelist && (peer->transfer->hash != NULL) && isdchash(peer->transfer->hash) && supports(peer, "tthf"))
 617     {
 618         buf = base32encode(peer->transfer->hash->buf, 24);
 619         ret = sprintf2("TTH/%.39s", buf);
 620         free(buf);
 621     } else {
 622         if((buf = icwcstombs(peer->transfer->path, "UTF-8")) == NULL)
 623             return(NULL);
 624         ret = pathnmdc2adc(buf);
 625         free(buf);
 626     }
 627     return(ret);
 628 }
 629
 630
 631 static int trresumecb(struct transfer *transfer, wchar_t *cmd, wchar_t *arg, struct dcpeer *peer)
 632 {
 633     if(!wcscmp(cmd, L"resume"))
 634     {
 635         if(arg == NULL)
 636         {
 637             flog(LOG_WARNING, "filter returned no position for \"resume\" on transfer %i", transfer->id);
 638             freedcpeer(peer);
 639         } else {
 640             transfer->curpos = wcstol(arg, NULL, 10);
 641             peer->hascurpos = 1;
 642             requestfile(peer);
 643         }
 644         return(1);
 645     }
 646     return(0);
 647 }
 648
 649 static void sendmynick(struct dcpeer *peer)
 650 {
 651     struct fnetnode *fn;
 652
 653     fn = peer->fn;
 654     if(fn == NULL)
 655         qstrf(peer->sk, "$MyNick %s|", icswcstombs(confgetstr("cli", "defnick"), peer->charset, "DoldaConnectUser-IN"));
 656     else
 657         qstrf(peer->sk, "$MyNick %s|", icswcstombs(fn->mynick, peer->charset, "DoldaConnectUser-IN"));
 658 }
 659
 660 static void sendpeerlock(struct dcpeer *peer)
 661 {
 662     if(peer->dcppemu)
 663         qstrf(peer->sk, "$Lock EXTENDEDPROTOCOLABCABCABCABCABCABC Pk=DCPLUSPLUS0.674ABCABC|");
 664     else
 665         qstrf(peer->sk, "$Lock EXTENDEDPROTOCOLABCABCABCABCABCABC Pk=DOLDA%sABCABCABC|", VERSION);
 666 }
 667
 668 static void sendsupports(struct dcpeer *peer)
 669 {
 670     if(peer->dcppemu)
 671         qstr(peer->sk, "$Supports MiniSlots XmlBZList ADCGet TTHL TTHF GetZBlock ZLIG |");
 672     else
 673         qstr(peer->sk, "$Supports MiniSlots XmlBZList ADCGet TTHL TTHF GetZBlock ZLIG|");
 674 }
 675
 676 static void requestfile(struct dcpeer *peer)
 677 {
 678     char *buf;
 679
 680     if(peer->transfer->size == -1)
 681     {
 682         /* Use DCCHARSET for $Get paths until further researched... */
 683         if((buf = icswcstombs(peer->transfer->path, DCCHARSET, NULL)) == NULL)
 684         {
 685             transferseterror(peer->transfer, TRNSE_NOTFOUND);
 686             freedcpeer(peer);
 687             return;
 688         }
 689         /* The transfer will be restarted later from
 690          * cmd_filelength when it detects that the sizes
 691          * don't match. */
 692         qstrf(peer->sk, "$Get %s$1|", buf);
 693         return;
 694     }
 695     if((peer->transfer->hash == NULL) && !peer->notthl)
 696     {
 697         if(supports(peer, "adcget") && supports(peer, "tthl"))
 698         {
 699             qstr(peer->sk, "$ADCGET");
 700             sendadc(peer->sk, "tthl");
 701             if((buf = getadcid(peer)) == NULL)
 702             {
 703                 transferseterror(peer->transfer, TRNSE_NOTFOUND);
 704                 freedcpeer(peer);
 705                 return;
 706             }
 707             sendadc(peer->sk, buf);
 708             free(buf);
 709             sendadc(peer->sk, "0");
 710             sendadc(peer->sk, "-1");
 711             qstr(peer->sk, "|");
 712             peer->fetchingtthl = 1;
 713             return;
 714         }
 715     }
 716     if(!peer->hascurpos)
 717     {
 718         if(forkfilter(peer->transfer))
 719         {
 720             flog(LOG_WARNING, "could not fork filter for transfer %i: %s", peer->transfer->id, strerror(errno));
 721             freedcpeer(peer);
 722             return;
 723         }
 724         CBREG(peer->transfer, trans_filterout, (int (*)(struct transfer *, wchar_t *, wchar_t *, void *))trresumecb, NULL, peer);
 725         return;
 726     }
 727     if(supports(peer, "adcget"))
 728     {
 729         qstr(peer->sk, "$ADCGET");
 730         sendadc(peer->sk, "file");
 731         if((buf = getadcid(peer)) == NULL)
 732         {
 733             transferseterror(peer->transfer, TRNSE_NOTFOUND);
 734             freedcpeer(peer);
 735             return;
 736         }
 737         sendadc(peer->sk, buf);
 738         free(buf);
 739         sendadcf(peer->sk, "%i", peer->transfer->curpos);
 740         sendadcf(peer->sk, "%i", peer->transfer->size - peer->transfer->curpos);
 741         qstr(peer->sk, "|");
 742     } else if(supports(peer, "xmlbzlist")) {
 743         if((buf = icswcstombs(peer->transfer->path, "UTF-8", NULL)) == NULL)
 744         {
 745             transferseterror(peer->transfer, TRNSE_NOTFOUND);
 746             freedcpeer(peer);
 747             return;
 748         }
 749         qstrf(peer->sk, "$UGetBlock %zi %zi %s|", peer->transfer->curpos, peer->transfer->size - peer->transfer->curpos, buf);
 750     } else {
 751         /* Use DCCHARSET for $Get paths until further researched... */
 752         if((buf = icswcstombs(peer->transfer->path, DCCHARSET, NULL)) == NULL)
 753         {
 754             transferseterror(peer->transfer, TRNSE_NOTFOUND);
 755             freedcpeer(peer);
 756             return;
 757         }
 758         qstrf(peer->sk, "$Get %s$%zi|", buf, peer->transfer->curpos + 1);
 759     }
 760 }
 761
 762 static void sendmyinfo(struct socket *sk, struct fnetnode *fn)
 763 {
 764     struct dchub *hub;
 765     char *buf;
 766     struct fnetnode *cfn;
 767     int hn1, hn2, hn3;
 768
 769     hub = fn->data;
 770     qstrf(sk, "$MyINFO $ALL %s ", hub->nativenick);
 771     buf = tr(icswcstombs(confgetstr("dc", "desc"), hub->charset, "Charset_conv_failure"), "$_|_");
 772     qstrf(sk, "%s", buf);
 773     hn1 = hn2 = hn3 = 0;
 774     for(cfn = fnetnodes; cfn != NULL; cfn = cfn->next)
 775     {
 776         if((cfn->state == FNN_EST) || (cfn->state == FNN_HS))
 777         {
 778             if(cfn->regstatus == FNNS_OP)
 779                 hn3++;
 780             else if(cfn->regstatus == FNNS_REG)
 781                 hn2++;
 782             else
 783                 hn1++;
 784         }
 785     }
 786     qstrf(sk, "<%s V:%s,M:%c,H:%i/%i/%i,S:%i>",
 787           (hub->dcppemu)?"++":"Dolda",
 788           (hub->dcppemu)?"0.674":VERSION,
 789           (tcpsock == NULL)?'P':'A',
 790           hn1, hn2, hn3,
 791           confgetint("transfer", "slots")
 792           );
 793     qstrf(sk, "$ $");
 794     buf = tr(icswcstombs(confgetstr("dc", "speedstring"), hub->charset, "Charset_conv_failure"), "$_|_");
 795     qstrf(sk, "%s\x01$", buf);
 796     buf = tr(icswcstombs(confgetstr("dc", "email"), hub->charset, "Charset_conv_failure"), "$_|_");
 797     qstrf(sk, "%s$", buf);
 798     qstrf(sk, "%llu$|", sharesize);
 799 }
 800
 801 static void hubhandleaction(struct socket *sk, struct fnetnode *fn, char *cmd, char *args)
 802 {
 803     struct dchub *hub;
 804
 805     hub = fn->data;
 806     if(!strcmp(cmd, "$Lock"))
 807     {
 808         qstrf(sk, "$ValidateNick %s|", hub->nativenick);
 809     } else if(!strcmp(cmd, "$Hello")) {
 810         if(fn->state == FNN_HS)
 811         {
 812             qstrf(sk, "$Version 1,0091|");
 813             qstrf(sk, "$GetNickList|");
 814             sendmyinfo(sk, fn);
 815             fnetsetstate(fn, FNN_EST);
 816         } else {
 817             qstrf(sk, "$GetINFO %s %s|", args, hub->nativenick);
 818         }
 819     }
 820 }
 821
 822 static void cmd_lock(struct socket *sk, struct fnetnode *fn, char *cmd, char *args)
 823 {
 824     struct dchub *hub;
 825     char *key;
 826     char *p;
 827
 828     hub = fn->data;
 829     if(!strncmp(args, "EXTENDEDPROTOCOL", 16))
 830         hub->extended = 1;
 831     if((p = strchr(args, ' ')) != NULL)
 832         *(p++) = 0;
 833     if(hub->extended)
 834     {
 835         if(hub->dcppemu)
 836             qstrf(sk, "$Supports UserCommand NoGetINFO NoHello UserIP2 TTHSearch GetZBlock |");
 837         else
 838             qstrf(sk, "$Supports UserCommand NoGetINFO NoHello UserIP2 TTHSearch GetZBlock|");
 839     }
 840     key = dcmakekey(args);
 841     qstrf(sk, "$Key %s|", key);
 842     free(key);
 843     hubhandleaction(sk, fn, cmd, args);
 844 }
 845
 846 static void cmd_hubname(struct socket *sk, struct fnetnode *fn, char *cmd, char *args)
 847 {
 848     wchar_t *buf;
 849     struct dchub *hub;
 850
 851     hub = fn->data;
 852     if(hub->nativename == NULL)
 853         free(hub->nativename);
 854     hub->nativename = sstrdup(args);
 855     buf = icmbstowcs(args, hub->charset);
 856     fnetsetname(fn, (buf == NULL)?L"Hubname conv error":buf);
 857     if(buf != NULL)
 858         free(buf);
 859     hubhandleaction(sk, fn, cmd, args);
 860 }
 861
 862 static void cmd_hello(struct socket *sk, struct fnetnode *fn, char *cmd, char *args)
 863 {
 864     wchar_t *nick;
 865     struct dchub *hub;
 866
 867     hub = fn->data;
 868     if((nick = icmbstowcs(args, hub->charset)) == NULL)
 869         return;
 870     if(strcmp(args, hub->nativenick) && (fnetfindpeer(fn, nick) == NULL))
 871         fnetaddpeer(fn, nick, nick);
 872     free(nick);
 873     hubhandleaction(sk, fn, cmd, args);
 874 }
 875
 876 static void cmd_quit(struct socket *sk, struct fnetnode *fn, char *cmd, char *args)
 877 {
 878     wchar_t *nick;
 879     struct fnetpeer *peer;
 880     struct dchub *hub;
 881
 882     hub = fn->data;
 883     if((nick = icmbstowcs(args, hub->charset)) == NULL)
 884         return;
 885     if((peer = fnetfindpeer(fn, nick)) != NULL)
 886         fnetdelpeer(peer);
 887     free(nick);
 888     hubhandleaction(sk, fn, cmd, args);
 889 }
 890
 891 static void cmd_nicklist(struct socket *sk, struct fnetnode *fn, char *cmd, char *args)
 892 {
 893     struct dchub *hub;
 894     char *p;
 895     wchar_t *buf;
 896     struct fnetpeer *peer, *npeer;
 897
 898     hub = fn->data;
 899     for(peer = fn->peers; peer != NULL; peer = peer->next)
 900         peer->flags.b.delete = 1;
 901     while((p = strstr(args, "$$")) != NULL)
 902     {
 903         *p = 0;
 904         if((buf = icmbstowcs(args, hub->charset)) != NULL)
 905         {
 906             if((peer = fnetfindpeer(fn, buf)) == NULL)
 907                 peer = fnetaddpeer(fn, buf, buf);
 908             else
 909                 peer->flags.b.delete = 0;
 910             free(buf);
 911             qstrf(sk, "$GetINFO %s %s|", args, hub->nativenick);
 912         }
 913         args = p + 2;
 914     }
 915     for(peer = fn->peers; peer != NULL; peer = npeer)
 916     {
 917         npeer = peer->next;
 918         if(peer->flags.b.delete)
 919             fnetdelpeer(peer);
 920     }
 921     hubhandleaction(sk, fn, cmd, args);
 922 }
 923
 924 static void cmd_oplist(struct socket *sk, struct fnetnode *fn, char *cmd, char *args)
 925 {
 926     struct dchub *hub;
 927     char *p;
 928     wchar_t *buf;
 929     struct fnetpeer *peer;
 930
 931     hub = fn->data;
 932     for(peer = fn->peers; peer != NULL; peer = peer->next)
 933         peer->flags.b.op = 0;
 934     while((p = strstr(args, "$$")) != NULL)
 935     {
 936         *p = 0;
 937         if((buf = icmbstowcs(args, hub->charset)) != NULL)
 938         {
 939             if((peer = fnetfindpeer(fn, buf)) != NULL)
 940                 peer->flags.b.op = 1;
 941             free(buf);
 942         }
 943         args = p + 2;
 944     }
 945     hubhandleaction(sk, fn, cmd, args);
 946 }
 947
 948 static void cmd_myinfo(struct socket *sk, struct fnetnode *fn, char *cmd, char *args)
 949 {
 950     char *p, *p2;
 951     wchar_t *buf, *wp, *wp2;
 952     wchar_t abuf[10];
 953     struct fnetpeer *peer;
 954     struct dchub *hub;
 955
 956     hub = fn->data;
 957     p = args;
 958     if(strncmp(p, "$ALL ", 5))
 959         return;
 960     p += 5;
 961     if((p2 = strchr(p, ' ')) == NULL)
 962         return;
 963     *p2 = 0;
 964     if((buf = icmbstowcs(p, hub->charset)) == NULL)
 965         return;
 966     if((peer = fnetfindpeer(fn, buf)) == NULL)
 967         peer = fnetaddpeer(fn, buf, buf);
 968     free(buf);
 969     p = p2 + 1;
 970     if((p2 = strstr(p, "$ $")) == NULL)
 971         return;
 972     *p2 = 0;
 973     if((buf = icmbstowcs(p, hub->charset)) == NULL)
 974         return;
 975     if((wcslen(buf) > 0) && (buf[wcslen(buf) - 1] == L'>') && ((wp = wcsrchr(buf, L'<')) != NULL))
 976     {
 977         buf[wcslen(buf) - 1] = L'\0';
 978         *(wp++) = L'\0';
 979         if((wp2 = wcschr(wp, L' ')) != NULL)
 980         {
 981             *(wp2++) = L'\0';
 982             fnetpeersetstr(peer, L"dc-client", wp);
 983             wp = wp2;
 984             do
 985             {
 986                 if((wp2 = wcschr(wp, L',')) != NULL)
 987                     *(wp2++) = L'\0';
 988                 if(wp[1] != L':')
 989                     continue;
 990                 swprintf(abuf, 10, L"dc-tag-%lc", wp[0]);
 991                 fnetpeersetstr(peer, abuf, wp + 2);
 992                 wp = wp2;
 993             } while(wp2 != NULL);
 994         }
 995     }
 996     fnetpeersetstr(peer, L"descr", buf);
 997     free(buf);
 998     p = p2 + 3;
 999     if((p2 = strchr(p, '$')) == NULL)
1000         return;
1001     *(p2 - 1) = 0;
1002     if((buf = icmbstowcs(p, hub->charset)) == NULL)
1003         return;
1004     fnetpeersetstr(peer, L"dc-speed", buf);
1005     free(buf);
1006     p = p2 + 1;
1007     if((p2 = strchr(p, '$')) == NULL)
1008         return;
1009     *p2 = 0;
1010     if((buf = icmbstowcs(p, hub->charset)) == NULL)
1011         return;
1012     fnetpeersetstr(peer, L"email", buf);
1013     free(buf);
1014     p = p2 + 1;
1015     if(strlen(p) < 1)
1016         return;
1017     fnetpeersetlnum(peer, L"share", strtoll(p, NULL, 10));
1018     hubhandleaction(sk, fn, cmd, args);
1019 }
1020
1021 /* I do not implement the fully in that I do not disconnect from the
1022  * old hub. I do this since I believe that if the hub owner really
1023  * wants to get rid of us, then it is his responsibility to disconnect
1024  * us. */
1025 static void cmd_forcemove(struct socket *sk, struct fnetnode *fn, char *cmd, char *args)
1026 {
1027     struct dchub *hub;
1028     struct fnetnode *newfn;
1029     int freeargs;
1030
1031     hub = fn->data;
1032     if(strchr(args, ':') == NULL)
1033     {
1034         args = strcpy(smalloc(strlen(args) + 5), args);
1035         strcat(args, ":411");
1036         freeargs = 1;
1037     } else {
1038         freeargs = 0;
1039     }
1040     if((newfn = fnetinitconnect(L"dc", fn->owner, args, NULL)) != NULL)
1041     {
1042         linkfnetnode(newfn);
1043         putfnetnode(newfn);
1044     }
1045     hubhandleaction(sk, fn, cmd, args);
1046     if(freeargs)
1047         free(args);
1048 }
1049
1050 static char *getdcpath(struct sharecache *node, size_t *retlen, char *charset)
1051 {
1052     char *buf, *buf2;
1053     size_t len, len2;
1054
1055     if(node->parent == NULL)
1056         return(NULL);
1057     if(node->parent == shareroot)
1058     {
1059         if((buf = icwcstombs(node->name, charset)) == NULL)
1060             return(NULL);
1061         if(retlen != NULL)
1062             *retlen = strlen(buf);
1063         return(buf);
1064     } else {
1065         if((buf2 = icwcstombs(node->name, charset)) == NULL)
1066             return(NULL);
1067         if((buf = getdcpath(node->parent, &len, charset)) == NULL)
1068         {
1069             free(buf2);
1070             return(NULL);
1071         }
1072         len2 = strlen(buf2);
1073         buf = srealloc(buf, len + 1 + len2 + 1);
1074         buf[len++] = '\\';
1075         strcpy(buf + len, buf2);
1076         buf[len + len2] = 0;
1077         free(buf2);
1078         if(retlen != NULL)
1079             *retlen = len + len2;
1080         return(buf);
1081     }
1082 }
1083
1084 /*
1085  * This is the main share searching function for Direct Connect
1086  * peers. Feel free to optimize it if you feel the need for it. I
1087  * haven't ever seen it take any noticable CPU time anyway, so I
1088  * haven't felt that need.
1089  *
1090  * It may feel dubious to just return the directory when all terms are
1091  * satisfied rather than all the files in it, but it really benefits
1092  * everyone: Less cycles used for us, less UDP squelching for active
1093  * searchers, and less bandwidth waste for hubs when serving passive
1094  * searchers.
1095  */
1096 static void cmd_search(struct socket *sk, struct fnetnode *fn, char *cmd, char *args)
1097 {
1098     int i, done;
1099     struct dchub *hub;
1100     char *p, *p2;
1101     char *prefix, *infix, *postfix, *buf, *buf2;
1102     struct socket *dsk;
1103     struct sockaddr_in addr;
1104     struct sharecache *node;
1105     int minsize, maxsize;
1106     int dotth;
1107     size_t buflen;
1108     int termnum, satisfied, skipcheck;
1109     int level, tersat[32];
1110     wchar_t *terms[32];
1111     char hashtth[24];
1112
1113     hub = fn->data;
1114     if((p = strchr(args, ' ')) == NULL)
1115         return;
1116     *(p++) = 0;
1117
1118     memset(terms, 0, sizeof(terms));
1119     prefix = infix = postfix = NULL;
1120     dsk = NULL;
1121     dotth = 0;
1122
1123     if(!strncmp(args, "Hub:", 4))
1124     {
1125         if(!strcmp(cmd, "$MultiSearch"))
1126             goto out;
1127         if(!strcmp(args + 4, hub->nativenick))
1128             goto out;
1129         prefix = sprintf2("$SR %s ", hub->nativenick);
1130         infix = sprintf2(" %i/%i\005", slotsleft(), confgetint("transfer", "slots"));
1131         postfix = sprintf2(" (%s)\005%s|", formataddress(hub->sk->remote, hub->sk->remotelen), args + 4);
1132         dsk = sk;
1133         getsock(dsk);
1134     } else {
1135         if((p2 = strchr(args, ':')) == NULL)
1136             goto out;
1137         *(p2++) = 0;
1138         addr.sin_family = AF_INET;
1139         if(!inet_aton(args, &addr.sin_addr))
1140             goto out;
1141         addr.sin_port = htons(atoi(p2));
1142         prefix = sprintf2("$SR %s ", hub->nativenick);
1143         infix = sprintf2(" %i/%i\005", slotsleft(), confgetint("transfer", "slots"));
1144         postfix = sprintf2(" (%s)|", formataddress(hub->sk->remote, hub->sk->remotelen));
1145         netdgramconn(dsk = netdupsock(udpsock), (struct sockaddr *)&addr, sizeof(addr));
1146     }
1147
1148     minsize = maxsize = -1;
1149     if(*p == 0)
1150         goto out;
1151     if(*(p++) == 'T')
1152         minsize = 0;
1153     if(*(p++) != '?')
1154         goto out;
1155     if(*p == 0)
1156         goto out;
1157     if((*(p++) == 'T') && (minsize == 0))
1158     {
1159         maxsize = 0;
1160         minsize = -1;
1161     }
1162     if(*(p++) != '?')
1163         goto out;
1164     if((p2 = strchr(p, '?')) == NULL)
1165         goto out;
1166     *(p2++) = 0;
1167     if(minsize == 0)
1168         minsize = atoi(p);
1169     if(maxsize == 0)
1170         maxsize = atoi(p);
1171     p = p2 + 1;
1172     if(*(p++) != '?')
1173         goto out;
1174     termnum = 0;
1175     p2 = p;
1176     done = 0;
1177     while(!done)
1178     {
1179         if((*p2 == 0) || (*p2 == '$'))
1180         {
1181             if(*p2 == 0)
1182                 done = 1;
1183             else
1184                 *p2 = 0;
1185             if(*p)
1186             {
1187                 if(!dotth && !strncmp(p, "TTH:", 4))
1188                 {
1189                     dotth = 1;
1190                     if(((buf = base32decode(p + 4, &buflen)) == NULL) || (buflen != 24))
1191                     {
1192                         free(buf);
1193                         goto out;
1194                     }
1195                     memcpy(hashtth, buf, 24);
1196                     free(buf);
1197                 } else {
1198                     if((terms[termnum] = icmbstowcs(p, hub->charset)) != NULL)
1199                         termnum++;
1200                 }
1201             }
1202             p = p2 + 1;
1203             if(termnum == 32)
1204                 break;
1205         }
1206         p2++;
1207     }
1208
1209     node = shareroot->child;
1210     level = 0;
1211     for(i = 0; i < termnum; i++)
1212         tersat[i] = -1;
1213     satisfied = 0;
1214     while(1)
1215     {
1216         skipcheck = 0;
1217         if(node->f.b.type == FILE_REG)
1218         {
1219             if((minsize >= 0) && (node->size < minsize))
1220                 skipcheck = 1;
1221             if((maxsize >= 0) && (node->size > maxsize))
1222                 skipcheck = 1;
1223         }
1224         if(!skipcheck && dotth)
1225         {
1226             if((node->f.b.type != FILE_REG) || (node->f.b.hastth && memcmp(hashtth, node->hashtth, 24)))
1227                 skipcheck = 1;
1228         }
1229         if(!skipcheck)
1230         {
1231             for(i = 0; i < termnum; i++)
1232             {
1233                 if(tersat[i] >= 0)
1234                     continue;
1235                 if(wcsexists(node->name, terms[i]))
1236                 {
1237                     tersat[i] = level;
1238                     satisfied++;
1239                 } else if(node->child == NULL) {
1240                     break;
1241                 }
1242             }
1243         }
1244         if(!skipcheck && (satisfied == termnum))
1245         {
1246             /* Use DCCHARSET in $Get paths until further researched... */
1247             if((buf = getdcpath(node, NULL, DCCHARSET)) != NULL)
1248             {
1249                 if(node->f.b.hastth)
1250                 {
1251                     buf2 = base32encode(node->hashtth, 24);
1252                     qstrf(dsk, "%s%s\005%zi%sTTH:%.39s%s", prefix, buf, node->size, infix, buf2, postfix);
1253                     free(buf2);
1254                 } else {
1255                     qstrf(dsk, "%s%s\005%zi%s%s%s", prefix, buf, node->size, infix, hub->nativename, postfix);
1256                 }
1257                 free(buf);
1258             }
1259         }
1260         if((!skipcheck && (satisfied == termnum)) || (node->child == NULL))
1261         {
1262             while(node->next == NULL)
1263             {
1264                 if((node = node->parent) == shareroot)
1265                     break;
1266                 level--;
1267             }
1268             if(node == shareroot)
1269                 break;
1270             for(i = 0; i < termnum; i++)
1271             {
1272                 if(tersat[i] >= level)
1273                 {
1274                     tersat[i] = -1;
1275                     satisfied--;
1276                 }
1277             }
1278             node = node->next;
1279         } else {
1280             node = node->child;
1281             level++;
1282         }
1283     }
1284
1285     hubhandleaction(sk, fn, cmd, args);
1286
1287  out:
1288     if(dsk != NULL)
1289         putsock(dsk);
1290     if(prefix != NULL)
1291         free(prefix);
1292     if(infix != NULL)
1293         free(infix);
1294     if(postfix != NULL)
1295         free(postfix);
1296     for(i = 0; (i < 32) && (terms[i] != NULL); i++)
1297         free(terms[i]);
1298 }
1299
1300 static void cmd_connecttome(struct socket *sk, struct fnetnode *fn, char *cmd, char *args)
1301 {
1302     char *p;
1303     struct dchub *hub;
1304     struct socket *newsk;
1305     struct sockaddr_in addr;
1306
1307     hub = fn->data;
1308     if((p = strchr(args, ' ')) == NULL)
1309         return;
1310     *(p++) = 0;
1311     if(strcmp(args, hub->nativenick))
1312         return;
1313     addr.sin_family = AF_INET;
1314     args = p;
1315     if((p = strchr(args, ':')) == NULL)
1316         return;
1317     *(p++) = 0;
1318     addr.sin_port = htons(atoi(p));
1319     if(!inet_aton(args, &addr.sin_addr))
1320         return;
1321     newsk = netcsconn((struct sockaddr *)&addr, sizeof(addr), (void (*)(struct socket *, int, void *))peerconnect, fn);
1322     getfnetnode(fn);
1323     hubhandleaction(sk, fn, cmd, args);
1324 }
1325
1326 static void sendctm(struct socket *sk, char *nick)
1327 {
1328     struct sockaddr *addr;
1329     socklen_t addrlen;
1330
1331     if(tcpsock == NULL)
1332         return;
1333     if(sockgetremotename2(tcpsock, sk, &addr, &addrlen) < 0)
1334         return;
1335     if(addr->sa_family == AF_INET)
1336         qstrf(sk, "$ConnectToMe %s %s|", nick, formataddress(addr, addrlen));
1337     else
1338         flog(LOG_WARNING, "Direct Connect TCP socket is suddenly not AF_INET, but %i", addr->sa_family);
1339     free(addr);
1340 }
1341
1342 static void cmd_revconnecttome(struct socket *sk, struct fnetnode *fn, char *cmd, char *args)
1343 {
1344     struct dchub *hub;
1345     char *p;
1346
1347     hub = fn->data;
1348     if((p = strchr(args, ' ')) == NULL)
1349         return;
1350     *(p++) = 0;
1351     if(strcmp(p, hub->nativenick))
1352         return;
1353     sendctm(sk, args);
1354     expectpeer(args, fn);
1355     hubhandleaction(sk, fn, cmd, args);
1356 }
1357
1358 static void cmd_getnetinfo(struct socket *sk, struct fnetnode *fn, char *cmd, char *args)
1359 {
1360     struct dchub *hub;
1361     struct fnetnode *node;
1362     int numhubs;
1363
1364     hub = fn->data;
1365     numhubs = 0;
1366     for(node = fnetnodes; node != NULL; node = node->next)
1367     {
1368         if(node->state == FNN_EST)
1369             numhubs++;
1370     }
1371     qstrf(sk, "$NetInfo %i$%i$%c$0|", confgetint("transfer", "slots"), numhubs, (tcpsock == NULL)?'P':'A');
1372     hubhandleaction(sk, fn, cmd, args);
1373 }
1374
1375 static void cmd_to(struct socket *sk, struct fnetnode *fn, char *cmd, char *args)
1376 {
1377     struct dchub *hub;
1378     char *p, *p2;
1379
1380     hub = fn->data;
1381     p = args;
1382     if((p2 = strchr(p, ' ')) == NULL)
1383         return;
1384     *(p2++) = 0;
1385     p = p2;
1386     if((p2 = strchr(p, ' ')) == NULL)
1387         return;
1388     *(p2++) = 0;
1389     if(strcmp(p, "From:"))
1390         return;
1391     p = p2;
1392     if((p2 = strstr(p, " $")) == NULL)
1393         return;
1394     *p2 = 0;
1395     p2 += 2;
1396     hubrecvchat(hub->sk, fn, p, p2);
1397     hubhandleaction(sk, fn, cmd, args);
1398 }
1399
1400 static void cmd_sr(struct socket *sk, struct fnetnode *fn, char *cmd, char *args)
1401 {
1402     struct dchub *hub;
1403     char *p, *p2, *buf;
1404     char *nick, *filename, *hubname;
1405     int size, slots;
1406     size_t buflen;
1407     struct srchres *sr;
1408     wchar_t *wnick, *wfile;
1409
1410     hub = fn->data;
1411     nick = p = args;
1412     if((p2 = strchr(p, ' ')) == NULL)
1413         return;
1414     *p2 = 0;
1415     p = p2 + 1;
1416     filename = p;
1417     if((p2 = strchr(p, 5)) == NULL)
1418         return;
1419     *p2 = 0;
1420     p = p2 + 1;
1421     if((p2 = strchr(p, ' ')) == NULL)
1422         return;
1423     *p2 = 0;
1424     size = atoi(p);
1425     p = p2 + 1;
1426     if((p2 = strchr(p, '/')) == NULL)
1427         return;
1428     *p2 = 0;
1429     slots = atoi(p);
1430     p = p2 + 1;
1431     if((p2 = strchr(p, 5)) == NULL)
1432         return;
1433     p = p2 + 1;
1434     hubname = p;
1435     if((p2 = strstr(p, " (")) == NULL)
1436         return;
1437     *p2 = 0;
1438     if((wnick = icmbstowcs(nick, hub->charset)) == NULL)
1439         return;
1440     /* Use DCCHARSET in $Get paths until further researched... */
1441     if((wfile = icmbstowcs(filename, DCCHARSET)) == NULL)
1442     {
1443         free(wnick);
1444         return;
1445     }
1446     sr = newsrchres(&dcnet, wfile, wnick);
1447     if(sr->peernick != NULL)
1448         free(sr->peernick);
1449     sr->peernick = swcsdup(wnick);
1450     sr->size = size;
1451     sr->slots = slots;
1452     free(wfile);
1453     free(wnick);
1454     if(!strncmp(hubname, "TTH:", 4))
1455     {
1456         if((buf = base32decode(hubname + 4, &buflen)) != NULL)
1457         {
1458             if(buflen == 24)
1459                 sr->hash = newhash(L"TTH", 24, buf);
1460             free(buf);
1461         }
1462     }
1463     getfnetnode(sr->fn = fn);
1464     submitsrchres(sr);
1465     freesrchres(sr);
1466     hubhandleaction(sk, fn, cmd, args);
1467 }
1468
1469 static void cmd_usercommand(struct socket *sk, struct fnetnode *fn, char *cmd, char *args)
1470 {
1471     /* Do nothing for now. */
1472 }
1473
1474 static void cmd_getpass(struct socket *sk, struct fnetnode *fn, char *cmd, char *args)
1475 {
1476     struct dchub *hub;
1477     wchar_t *pw;
1478     char *mbspw;
1479
1480     hub = fn->data;
1481     pw = wpfind(fn->args, L"password");
1482     if((pw == NULL) || ((mbspw = icwcstombs(pw, hub->charset)) == NULL))
1483     {
1484         killfnetnode(fn);
1485         return;
1486     }
1487     qstrf(sk, "$MyPass %s|", mbspw);
1488     free(mbspw);
1489     fn->regstatus = FNNS_REG;
1490     hubhandleaction(sk, fn, cmd, args);
1491 }
1492
1493 static void cmd_logedin(struct socket *sk, struct fnetnode *fn, char *cmd, char *args)
1494 {
1495     struct dchub *hub;
1496
1497     hub = fn->data;
1498     fn->regstatus = FNNS_OP;
1499     hubhandleaction(sk, fn, cmd, args);
1500 }
1501
1502 static void cmd_hubsupports(struct socket *sk, struct fnetnode *fn, char *cmd, char *args)
1503 {
1504     struct dchub *hub;
1505     int i;
1506     char *p, *p2;
1507     char **arr;
1508     size_t arrsize, arrdata;
1509
1510     hub = fn->data;
1511     if(hub->supports != NULL)
1512     {
1513         for(i = 0; hub->supports[i] != NULL; i++)
1514             free(hub->supports[i]);
1515         free(hub->supports);
1516     }
1517     arr = NULL;
1518     arrsize = arrdata = 0;
1519     p = args;
1520     do
1521     {
1522         if((p2 = strchr(p, ' ')) != NULL)
1523             *(p2++) = 0;
1524         if(*p == 0)
1525             continue;
1526         addtobuf(arr, sstrdup(p));
1527     } while((p = p2) != NULL);
1528     addtobuf(arr, NULL);
1529     hub->supports = arr;
1530 }
1531
1532 static void cmd_mynick(struct socket *sk, struct dcpeer *peer, char *cmd, char *args)
1533 {
1534     struct dcexppeer *expect;
1535     struct dchub *hub;
1536
1537     if(peer->nativename != NULL)
1538         free(peer->nativename);
1539     peer->nativename = sstrdup(args);
1540     if(peer->wcsname != NULL)
1541         free(peer->wcsname);
1542     if((peer->wcsname = icmbstowcs(peer->nativename, peer->charset)) == NULL)
1543     {
1544         freedcpeer(peer);
1545         return;
1546     }
1547     if(peer->accepted)
1548     {
1549         for(expect = expected; expect != NULL; expect = expect->next)
1550         {
1551             if(!strcmp(expect->nick, args))
1552                 break;
1553         }
1554         if(expect == NULL)
1555         {
1556             peer->fn = NULL;
1557         } else {
1558             hub = expect->fn->data;
1559             peer->fn = expect->fn;
1560             getfnetnode(peer->fn);
1561             peer->dcppemu = hub->dcppemu;
1562             freeexppeer(expect);
1563         }
1564     }
1565 }
1566
1567 static void cmd_direction(struct socket *sk, struct dcpeer *peer, char *cmd, char *args)
1568 {
1569     char *p;
1570     int mydir;
1571     struct transfer *transfer;
1572
1573     if((p = strchr(args, ' ')) == NULL)
1574         return;
1575     *p = 0;
1576     if(!strcmp(args, "Upload"))
1577         mydir = TRNSD_DOWN;
1578     if(!strcmp(args, "Download"))
1579         mydir = TRNSD_UP;
1580     if(peer->accepted)
1581     {
1582         if((peer->transfer == NULL) || (mydir != peer->direction))
1583         {
1584             freedcpeer(peer);
1585             return;
1586         }
1587         if(peer->direction == TRNSD_DOWN)
1588             requestfile(peer);
1589     } else {
1590         if(peer->wcsname == NULL)
1591         {
1592             freedcpeer(peer);
1593             return;
1594         }
1595         peer->direction = mydir;
1596         if(peer->direction == TRNSD_UP)
1597         {
1598             if(confgetint("transfer", "ulquota") && hasupload(&dcnet, peer->wcsname))
1599             {
1600                 freedcpeer(peer);
1601                 return;
1602             }
1603             transfer = newupload(peer->fn, &dcnet, peer->wcsname, &dctransfer, peer);
1604         } else {
1605             if((transfer = finddownload(peer->wcsname)) == NULL)
1606             {
1607                 freedcpeer(peer);
1608                 return;
1609             }
1610             transferattach(transfer, &dctransfer, peer);
1611             transfersetstate(transfer, TRNS_HS);
1612         }
1613         transfersetnick(transfer, peer->wcsname);
1614         peer->transfer = transfer;
1615         if(peer->extended)
1616             sendsupports(peer);
1617         qstrf(sk, "$Direction %s %i|", (peer->direction == TRNSD_UP)?"Upload":"Download", rand() % 10000);
1618         if(peer->key != NULL)
1619             qstrf(sk, "$Key %s|", peer->key);
1620         if(peer->direction == TRNSD_DOWN)
1621             requestfile(peer);
1622     }
1623 }
1624
1625 static void cmd_peerlock(struct socket *sk, struct dcpeer *peer, char *cmd, char *args)
1626 {
1627     char *p, *key;
1628     struct transfer *transfer;
1629
1630     if((p = strchr(args, ' ')) == NULL)
1631         return;
1632     *p = 0;
1633     if(!strncmp(args, "EXTENDEDPROTOCOL", 16))
1634         peer->extended = 1;
1635     key = dcmakekey(args);
1636     if(peer->accepted)
1637     {
1638         if(peer->wcsname == NULL)
1639         {
1640             freedcpeer(peer);
1641             return;
1642         }
1643         sendmynick(peer);
1644         sendpeerlock(peer);
1645         if(peer->extended)
1646             sendsupports(peer);
1647         if((transfer = finddownload(peer->wcsname)) == NULL)
1648         {
1649             if(confgetint("transfer", "ulquota") && hasupload(&dcnet, peer->wcsname))
1650             {
1651                 freedcpeer(peer);
1652                 return;
1653             }
1654             peer->direction = TRNSD_UP;
1655             transfer = newupload(peer->fn, &dcnet, peer->wcsname, &dctransfer, peer);
1656         } else {
1657             peer->direction = TRNSD_DOWN;
1658             transferattach(transfer, &dctransfer, peer);
1659             transfersetstate(transfer, TRNS_HS);
1660         }
1661         transfersetnick(transfer, peer->wcsname);
1662         peer->transfer = transfer;
1663         qstrf(sk, "$Direction %s %i|", (peer->direction == TRNSD_UP)?"Upload":"Download", rand() % 10000);
1664         qstrf(sk, "$Key %s|", key);
1665         free(key);
1666     } else {
1667         if(peer->key != NULL)
1668             free(peer->key);
1669         peer->key = key;
1670     }
1671 }
1672
1673 static void cmd_key(struct socket *sk, struct dcpeer *peer, char *cmd, char *args)
1674 {
1675     /* NOP */
1676 }
1677
1678 static void startdl(struct dcpeer *peer)
1679 {
1680     if(peer->timeout != NULL)
1681         canceltimer(peer->timeout);
1682     peer->state = PEER_TRNS;
1683     transferstartdl(peer->transfer, peer->sk);
1684     peer->sk->readcb = (void (*)(struct socket *, void *))transread;
1685     peer->sk->errcb = (void (*)(struct socket *, int, void *))transerr;
1686 }
1687
1688 static void startul(struct dcpeer *peer)
1689 {
1690     if(peer->timeout != NULL)
1691         canceltimer(peer->timeout);
1692     peer->state = PEER_TRNS;
1693     transferstartul(peer->transfer, peer->sk);
1694     peer->sk->writecb = (void (*)(struct socket *, void *))transwrite;
1695 }
1696
1697 static void cmd_filelength(struct socket *sk, struct dcpeer *peer, char *cmd, char *args)
1698 {
1699     int size;
1700     struct transfer *transfer;
1701
1702     if(peer->transfer == NULL)
1703     {
1704         freedcpeer(peer);
1705         return;
1706     }
1707     size = atoi(args);
1708     if(peer->transfer->size != size)
1709     {
1710         transfersetsize(peer->transfer, size);
1711         transfer = peer->transfer;
1712         freedcpeer(peer);
1713         trytransferbypeer(transfer->fnet, transfer->peerid);
1714         return;
1715     }
1716     startdl(peer);
1717     qstr(peer->sk, "$Send|");
1718 }
1719
1720 static void cmd_error(struct socket *sk, struct dcpeer *peer, char *cmd, char *args)
1721 {
1722     if(peer->fetchingtthl)
1723     {
1724         peer->fetchingtthl = 0;
1725         peer->notthl = 1;
1726         requestfile(peer);
1727         return;
1728     }
1729     if((peer->transfer != NULL) && (peer->transfer->dir == TRNSD_DOWN))
1730     {
1731         transferseterror(peer->transfer, TRNSE_NOTFOUND);
1732         resettransfer(peer->transfer);
1733         return;
1734     }
1735     freedcpeer(peer);
1736 }
1737
1738 static void cmd_maxedout(struct socket *sk, struct dcpeer *peer, char *cmd, char *args)
1739 {
1740     if((peer->transfer != NULL) && (peer->transfer->dir == TRNSD_DOWN))
1741     {
1742         transferseterror(peer->transfer, TRNSE_NOSLOTS);
1743         resettransfer(peer->transfer);
1744         return;
1745     }
1746     freedcpeer(peer);
1747 }
1748
1749 static struct
1750 {
1751     char *name;
1752     char **file;
1753     void (*func)(void);
1754 } lists[] =
1755 {
1756     {"MyList.DcLst", &hmlistname, updatehmlist},
1757     {"files.xml", &xmllistname, updatexmllist},
1758     {"files.xml.bz2", &xmlbz2listname, updatexmlbz2list},
1759     {NULL, NULL}
1760 };
1761
1762 static int openfilelist(char *name)
1763 {
1764     int i, fd;
1765     int errnobak;
1766
1767     for(i = 0; lists[i].name != NULL; i++)
1768     {
1769         if(!strcmp(name, lists[i].name))
1770             break;
1771     }
1772     errno = 0;
1773     if(lists[i].name == NULL)
1774         return(-1);
1775     fd = -1;
1776     if((*lists[i].file == NULL) || ((fd = open(*lists[i].file, O_RDONLY)) < 0))
1777         lists[i].func();
1778     if((fd < 0) && ((*lists[i].file == NULL) || ((fd = open(*lists[i].file, O_RDONLY)) < 0)))
1779     {
1780         errnobak = errno;
1781         flog(LOG_ERR, "could not open filelist tempfile: %s", strerror(errno));
1782         errno = errnobak;
1783         return(-1);
1784     }
1785     return(fd);
1786 }
1787
1788 static struct sharecache *findbytth(char *tth32)
1789 {
1790     char *buf;
1791     size_t buflen;
1792     struct sharecache *node;
1793
1794     if((buf = base32decode(tth32, &buflen)) == NULL)
1795         return(NULL);
1796     if(buflen != 24)
1797     {
1798         free(buf);
1799         return(NULL);
1800     }
1801     for(node = shareroot->child; node != NULL; node = nextscnode(node))
1802     {
1803         if(node->f.b.hastth && !memcmp(node->hashtth, buf, 24))
1804             break;
1805     }
1806     free(buf);
1807     return(node);
1808 }
1809
1810 static struct sharecache *resdcpath(char *path, char *charset, char sep)
1811 {
1812     struct sharecache *node;
1813     char *p, *p2;
1814
1815     node = shareroot;
1816     p = path;
1817     while(p != NULL)
1818     {
1819         if((p2 = strchr(p, sep)) != NULL)
1820             *(p2++) = 0;
1821         if((node = findcache(node, icsmbstowcs(p, charset, L""))) == NULL)
1822             return(NULL);
1823         p = p2;
1824     }
1825     return(node);
1826 }
1827
1828 static void cmd_get(struct socket *sk, struct dcpeer *peer, char *cmd, char *args)
1829 {
1830     int offset;
1831     char *p, *buf;
1832     wchar_t *buf2;
1833     struct sharecache *node;
1834     struct socket *lesk;
1835     int fd;
1836     struct stat sb;
1837
1838     if(peer->transfer == NULL)
1839     {
1840         freedcpeer(peer);
1841         return;
1842     }
1843     if((p = strchr(args, '$')) == NULL)
1844     {
1845         freedcpeer(peer);
1846         return;
1847     }
1848     *(p++) = 0;
1849     if((offset = (atoi(p) - 1)) < 0)
1850     {
1851         freedcpeer(peer);
1852         return;
1853     }
1854     if(((fd = openfilelist(args)) < 0) && (errno != 0))
1855     {
1856         qstr(sk, "$Error Could not send file list|");
1857         freedcpeer(peer);
1858         return;
1859     } else if(fd >= 0) {
1860         if((buf2 = icsmbstowcs(args, DCCHARSET, NULL)) != NULL)
1861             transfersetpath(peer->transfer, buf2);
1862         peer->transfer->flags.b.minislot = 1;
1863     }
1864     if(fd < 0)
1865     {
1866         /* Use DCCHARSET in $Get paths until further researched... */
1867         if((node = resdcpath(args, DCCHARSET, '\\')) == NULL)
1868         {
1869             qstrf(sk, "$Error File not in share|");
1870             freedcpeer(peer);
1871             return;
1872         }
1873         if((fd = opensharecache(node)) < 0)
1874         {
1875             qstrf(sk, "$Error %s|", strerror(errno));
1876             freedcpeer(peer);
1877             return;
1878         }
1879         buf = getfspath(node);
1880         if((buf2 = icsmbstowcs(buf, NULL, NULL)) == NULL)
1881             flog(LOG_WARNING, "could not convert native path into a wcs (%s): %s", buf, strerror(errno));
1882         else
1883             transfersetpath(peer->transfer, buf2);
1884         free(buf);
1885     }
1886     if(fstat(fd, &sb) < 0)
1887     {
1888         close(fd);
1889         flog(LOG_WARNING, "could not stat file %ls: %s", node->name, strerror(errno));
1890         qstrf(sk, "$Error|");
1891         freedcpeer(peer);
1892         return;
1893     }
1894     if(sb.st_size < 65536)
1895         peer->transfer->flags.b.minislot = 1;
1896     if(!peer->transfer->flags.b.minislot && (slotsleft() < 1)) {
1897         close(fd);
1898         qstr(sk, "$MaxedOut|");
1899         freedcpeer(peer);
1900         return;
1901     }
1902     if((offset != 0) && (lseek(fd, offset, SEEK_SET) < 0))
1903     {
1904         close(fd);
1905         qstrf(sk, "$Error Offset out of range|");
1906         freedcpeer(peer);
1907         return;
1908     }
1909     lesk = wrapsock(fd);
1910     transferprepul(peer->transfer, sb.st_size, offset, -1, lesk);
1911     putsock(lesk);
1912     qstrf(sk, "$FileLength %zi|", peer->transfer->size);
1913 }
1914
1915 static void cmd_send(struct socket *sk, struct dcpeer *peer, char *cmd, char *args)
1916 {
1917     if(peer->transfer == NULL)
1918     {
1919         freedcpeer(peer);
1920         return;
1921     }
1922     if(peer->transfer->localend == NULL)
1923     {
1924         freedcpeer(peer);
1925         return;
1926     }
1927     peer->ptclose = 1;
1928     startul(peer);
1929 }
1930
1931 static void cmd_supports(struct socket *sk, struct dcpeer *peer, char *cmd, char *args)
1932 {
1933     int i;
1934     char *p, *p2;
1935     char **arr;
1936     size_t arrsize, arrdata;
1937
1938     if(peer->supports != NULL)
1939     {
1940         for(i = 0; peer->supports[i] != NULL; i++)
1941             free(peer->supports[i]);
1942         free(peer->supports);
1943     }
1944     arr = NULL;
1945     arrsize = arrdata = 0;
1946     p = args;
1947     do
1948     {
1949         if((p2 = strchr(p, ' ')) != NULL)
1950             *(p2++) = 0;
1951         if(*p == 0)
1952             continue;
1953         addtobuf(arr, sstrdup(p));
1954     } while((p = p2) != NULL);
1955     addtobuf(arr, NULL);
1956     peer->supports = arr;
1957 }
1958
1959 static void cmd_getblock(struct socket *sk, struct dcpeer *peer, char *cmd, char *args)
1960 {
1961     int fd;
1962     char *p, *p2;
1963     int start, numbytes;
1964     char *charset, *buf;
1965     wchar_t *buf2;
1966     struct sharecache *node;
1967     struct stat sb;
1968     struct socket *lesk;
1969
1970     if(peer->transfer == NULL)
1971     {
1972         freedcpeer(peer);
1973         return;
1974     }
1975     p = args;
1976     if((p2 = strchr(p, ' ')) == NULL)
1977     {
1978         freedcpeer(peer);
1979         return;
1980     }
1981     *(p2++) = 0;
1982     start = atoi(p);
1983     p = p2;
1984     if((p2 = strchr(p, ' ')) == NULL)
1985     {
1986         freedcpeer(peer);
1987         return;
1988     }
1989     *(p2++) = 0;
1990     numbytes = atoi(p);
1991     p = p2;
1992     if(!strcmp(cmd, "$UGetBlock") || !strcmp(cmd, "$UGetZBlock"))
1993         charset = "UTF-8";
1994     else
1995         /* Use DCCHARSET in $Get paths until further researched... */
1996         charset = DCCHARSET;
1997     if(!strcmp(cmd, "$GetZBlock") || !strcmp(cmd, "$UGetZBlock"))
1998         initcompress(peer, CPRS_ZLIB);
1999     if(((fd = openfilelist(p)) < 0) && (errno != 0))
2000     {
2001         qstr(sk, "$Error Could not send file list|");
2002         return;
2003     } else if(fd >= 0) {
2004         if((buf2 = icsmbstowcs(args, charset, NULL)) != NULL)
2005             transfersetpath(peer->transfer, buf2);
2006         peer->transfer->flags.b.minislot = 1;
2007     }
2008     if(fd < 0)
2009     {
2010         if((node = resdcpath(p, charset, '\\')) == NULL)
2011         {
2012             qstr(sk, "$Error File not in cache|");
2013             return;
2014         }
2015         if((fd = opensharecache(node)) < 0)
2016         {
2017             qstrf(sk, "$Error %s|", strerror(errno));
2018             return;
2019         }
2020         buf = getfspath(node);
2021         if((buf2 = icsmbstowcs(buf, NULL, NULL)) == NULL)
2022             flog(LOG_WARNING, "could not convert native path into a wcs (%s): %s", buf, strerror(errno));
2023         else
2024             transfersetpath(peer->transfer, buf2);
2025         free(buf);
2026     }
2027     if(fstat(fd, &sb) < 0)
2028     {
2029         close(fd);
2030         flog(LOG_WARNING, "could not stat file %ls: %s", node->name, strerror(errno));
2031         qstr(sk, "$Error|");
2032         return;
2033     }
2034     if(sb.st_size < 65536)
2035         peer->transfer->flags.b.minislot = 1;
2036     if(!peer->transfer->flags.b.minislot && (slotsleft() < 1)) {
2037         close(fd);
2038         qstr(sk, "$MaxedOut|");
2039         return;
2040     }
2041     if((start != 0) && ((start >= sb.st_size) || (lseek(fd, start, SEEK_SET) < 0)))
2042     {
2043         close(fd);
2044         qstr(sk, "$Error Offset out of range|");
2045         return;
2046     }
2047     if((numbytes < 0) || (start + numbytes > sb.st_size))
2048         numbytes = sb.st_size - start;
2049     lesk = wrapsock(fd);
2050     transferprepul(peer->transfer, sb.st_size, start, start + numbytes, lesk);
2051     putsock(lesk);
2052     qstrf(sk, "$Sending %i|", numbytes);
2053     startul(peer);
2054 }
2055
2056 static void cmd_adcget(struct socket *sk, struct dcpeer *peer, char *cmd, char *args)
2057 {
2058     int i;
2059     char **argv, *buf;
2060     int start, numbytes;
2061     struct sharecache *node;
2062     struct stat sb;
2063     struct socket *lesk;
2064     wchar_t *wbuf;
2065     int fd;
2066
2067     if(peer->transfer == NULL)
2068     {
2069         freedcpeer(peer);
2070         return;
2071     }
2072     if((argv = parseadc(args)) == NULL)
2073     {
2074         freedcpeer(peer);
2075         return;
2076     }
2077     if(parrlen(argv) < 4)
2078     {
2079         freedcpeer(peer);
2080         goto out;
2081     }
2082     start = atoi(argv[2]);
2083     numbytes = atoi(argv[3]);
2084     node = NULL;
2085     fd = -1;
2086     if(((fd = openfilelist(argv[1])) < 0) && (errno != 0))
2087     {
2088         qstr(sk, "$Error Could not send file list|");
2089         goto out;
2090     } else if(fd >= 0) {
2091         if((wbuf = icsmbstowcs(argv[1], "UTF-8", NULL)) != NULL)
2092             transfersetpath(peer->transfer, wbuf);
2093         peer->transfer->flags.b.minislot = 1;
2094     }
2095     if(fd < 0)
2096     {
2097         if(!strncmp(argv[1], "TTH/", 4))
2098         {
2099             if((node = findbytth(argv[1] + 4)) == NULL)
2100             {
2101                 qstr(sk, "$Error File not in cache|");
2102                 goto out;
2103             }
2104         } else {
2105             if((node = resdcpath((argv[1][0] == '/')?(argv[1] + 1):(argv[1]), "UTF-8", '/')) == NULL)
2106             {
2107                 qstr(sk, "$Error File not in cache|");
2108                 goto out;
2109             }
2110         }
2111         if((fd = opensharecache(node)) < 0)
2112         {
2113             qstrf(sk, "$Error %s|", strerror(errno));
2114             goto out;
2115         }
2116         buf = getfspath(node);
2117         if((wbuf = icsmbstowcs(buf, NULL, NULL)) == NULL)
2118             flog(LOG_WARNING, "could not convert native path into a wcs (%s): %s", buf, strerror(errno));
2119         else
2120             transfersetpath(peer->transfer, wbuf);
2121         free(buf);
2122     }
2123     if(!strcmp(argv[0], "file"))
2124     {
2125         for(i = 4; argv[i] != NULL; i++)
2126         {
2127             if(!strcmp(argv[i], "ZL1"))
2128                 initcompress(peer, CPRS_ZLIB);
2129         }
2130         if(fstat(fd, &sb) < 0)
2131         {
2132             flog(LOG_WARNING, "could not stat file %ls: %s", node->name, strerror(errno));
2133             qstr(sk, "$Error|");
2134             goto out;
2135         }
2136         if(sb.st_size < 65536)
2137             peer->transfer->flags.b.minislot = 1;
2138         if(!peer->transfer->flags.b.minislot && (slotsleft() < 1)) {
2139             qstr(sk, "$MaxedOut|");
2140             goto out;
2141         }
2142         if((start != 0) && ((start >= sb.st_size) || (lseek(fd, start, SEEK_SET) < 0)))
2143         {
2144             qstr(sk, "$Error Offset out of range|");
2145             goto out;
2146         }
2147         if((numbytes < 0) || (start + numbytes > sb.st_size))
2148             numbytes = sb.st_size - start;
2149         lesk = wrapsock(fd);
2150         transferprepul(peer->transfer, sb.st_size, start, start + numbytes, lesk);
2151         putsock(lesk);
2152         fd = -1;
2153         qstr(sk, "$ADCSND");
2154         sendadc(sk, "file");
2155         sendadc(sk, argv[1]);
2156         sendadcf(sk, "%i", start);
2157         sendadcf(sk, "%i", numbytes);
2158         if(peer->compress == CPRS_ZLIB)
2159             sendadc(sk, "ZL1");
2160         qstr(sk, "|");
2161         startul(peer);
2162     } else if(!strcmp(argv[0], "tthl")) {
2163         /*
2164          * XXX: Implement full TTHL support.
2165          *
2166          * In the meantime, this is better than nothing, since it at
2167          * least allows fetching of the TTH root if it isn't already
2168          * known.
2169          */
2170         if(node == NULL)
2171         {
2172             qstr(sk, "$Error no TTHL data for virtual files|");
2173             goto out;
2174         }
2175         qstr(sk, "$ADCSND");
2176         sendadc(sk, "tthl");
2177         sendadc(sk, argv[1]);
2178         sendadc(sk, "0");
2179         sendadc(sk, "24");
2180         qstr(sk, "|");
2181         sockqueue(sk, node->hashtth, 24);
2182     } else {
2183         qstr(sk, "$Error Namespace not implemented|");
2184         goto out;
2185     }
2186
2187  out:
2188     if(fd >= 0)
2189         close(fd);
2190     freeparr(argv);
2191 }
2192
2193 static void handletthl(struct dcpeer *peer)
2194 {
2195     char buf[24];
2196
2197     while(peer->inbufdata >= 24)
2198     {
2199         pushtigertree(&peer->tth, peer->inbuf);
2200         memmove(peer->inbuf, peer->inbuf + 24, peer->inbufdata -= 24);
2201         peer->curread += 24;
2202     }
2203     if(peer->curread >= peer->totalsize)
2204     {
2205         if(peer->timeout == NULL)
2206             peer->timeout = timercallback(ntime() + 180, (void (*)(int, void *))peertimeout, peer);
2207         peer->state = PEER_CMD;
2208         synctigertree(&peer->tth);
2209         restigertree(&peer->tth, buf);
2210         transfersethash(peer->transfer, newhash(L"TTH", 24, buf));
2211         requestfile(peer);
2212     }
2213 }
2214
2215 static void cmd_adcsnd(struct socket *sk, struct dcpeer *peer, char *cmd, char *args)
2216 {
2217     char **argv;
2218     int start, numbytes;
2219
2220     if(peer->transfer == NULL)
2221     {
2222         freedcpeer(peer);
2223         return;
2224     }
2225     if((argv = parseadc(args)) == NULL)
2226     {
2227         freedcpeer(peer);
2228         return;
2229     }
2230     if(parrlen(argv) < 4)
2231     {
2232         freedcpeer(peer);
2233         goto out;
2234     }
2235     start = atoi(argv[2]);
2236     numbytes = atoi(argv[3]);
2237     if(!strcmp(argv[0], "tthl"))
2238     {
2239         if((start != 0) || (numbytes % 24 != 0))
2240         {
2241             /* Weird. Bail out. */
2242             freedcpeer(peer);
2243             goto out;
2244         }
2245         if(peer->timeout != NULL)
2246             canceltimer(peer->timeout);
2247         peer->state = PEER_TTHL;
2248         peer->totalsize = numbytes;
2249         peer->curread = 0;
2250         peer->fetchingtthl = 0;
2251         inittigertree(&peer->tth);
2252         handletthl(peer);
2253     } else if(!strcmp(argv[0], "file")) {
2254         if(start != peer->transfer->curpos)
2255         {
2256             freedcpeer(peer);
2257             goto out;
2258         }
2259         if(start + numbytes != peer->transfer->size)
2260         {
2261             transfersetsize(peer->transfer, start + numbytes);
2262             freedcpeer(peer);
2263             goto out;
2264         }
2265         startdl(peer);
2266         if(peer->inbufdata > 0)
2267         {
2268             sockpushdata(sk, peer->inbuf, peer->inbufdata);
2269             peer->inbufdata = 0;
2270             transread(sk, peer);
2271         }
2272     } else {
2273         /* We certainly didn't request this...*/
2274         freedcpeer(peer);
2275         goto out;
2276     }
2277
2278  out:
2279     freeparr(argv);
2280 }
2281
2282 static void cmd_sending(struct socket *sk, struct dcpeer *peer, char *cmd, char *args)
2283 {
2284     int numbytes;
2285
2286     if(peer->transfer == NULL)
2287     {
2288         freedcpeer(peer);
2289         return;
2290     }
2291     numbytes = atoi(args);
2292     if(peer->transfer->size - peer->transfer->curpos != numbytes)
2293     {
2294         transfersetsize(peer->transfer, peer->transfer->curpos + numbytes);
2295         freedcpeer(peer);
2296         return;
2297     }
2298     startdl(peer);
2299     if(peer->inbufdata > 0)
2300     {
2301         sockpushdata(sk, peer->inbuf, peer->inbufdata);
2302         peer->inbufdata = 0;
2303         transread(sk, peer);
2304     }
2305 }
2306
2307 /*
2308 Hub skeleton:
2309 static void cmd_(struct socket *sk, struct fnetnode *fn, char *cmd, char *args)
2310 {
2311     struct dchub *hub;
2312
2313     hub = fn->data;
2314     hubhandleaction(sk, fn, cmd, args);
2315 }
2316
2317 Peer skeleton:
2318 static void cmd_(struct socket *sk, struct dcpeer *peer, char *cmd, char *args)
2319 {
2320 }
2321
2322 */
2323
2324 static int hubreqconn(struct fnetpeer *peer)
2325 {
2326     struct dchub *hub;
2327     char *mbsnick;
2328
2329     if((peer->fn->state != FNN_EST) || (peer->fn->fnet != &dcnet))
2330     {
2331         errno = EINVAL;
2332         return(1);
2333     }
2334     if((hub = peer->fn->data) == NULL)
2335     {
2336         errno = EFAULT;
2337         return(1);
2338     }
2339     if((mbsnick = icwcstombs(peer->id, hub->charset)) == NULL)
2340         return(1); /* Shouldn't happen, of course, but who knows... */
2341     if(tcpsock != NULL)
2342     {
2343         sendctm(hub->sk, mbsnick);
2344         expectpeer(mbsnick, peer->fn);
2345     } else {
2346         qstrf(hub->sk, "$RevConnectToMe %s %s|", hub->nativenick, mbsnick);
2347     }
2348     free(mbsnick);
2349     return(0);
2350 }
2351
2352 static int hubsendchat(struct fnetnode *fn, int public, wchar_t *to, wchar_t *string)
2353 {
2354     struct dchub *hub;
2355     char *mbsstring, *mbsto;
2356
2357     hub = fn->data;
2358     if((mbsto = icwcstombs(to, hub->charset)) == NULL)
2359     {
2360         errno = EILSEQ;
2361         return(1);
2362     }
2363     if((mbsstring = icwcstombs(string, hub->charset)) == NULL)
2364     {
2365         errno = EILSEQ;
2366         return(1);
2367     }
2368     if((strchr(mbsto, '|') != NULL) || (strchr(mbsto, ' ') != NULL))
2369     {
2370         free(mbsto);
2371         free(mbsstring);
2372         errno = ESRCH;
2373         return(1);
2374     }
2375     if(strchr(mbsstring, '|') != NULL)
2376     {
2377         free(mbsto);
2378         free(mbsstring);
2379         errno = EILSEQ;
2380         return(1);
2381     }
2382     if(public)
2383     {
2384         if(*to == L'\0')
2385         {
2386             qstrf(hub->sk, "<%s> %s|", hub->nativenick, mbsstring);
2387         } else {
2388             qstrf(hub->sk, "$To: %s From: %s $<%s> %s|", mbsto, hub->nativenick, hub->nativenick, mbsstring);
2389         }
2390     } else {
2391         qstrf(hub->sk, "$To: %s From: %s $<%s> %s|", mbsto, hub->nativenick, hub->nativenick, mbsstring);
2392     }
2393     free(mbsto);
2394     free(mbsstring);
2395     return(0);
2396 }
2397
2398 static void findsizelimit(struct sexpr *sexpr, int *min, int *max)
2399 {
2400     int minl, maxl, minr, maxr, retmin, retmax;
2401
2402     switch(sexpr->op)
2403     {
2404     case SOP_AND:
2405         findsizelimit(sexpr->l, &minl, &maxl);
2406         findsizelimit(sexpr->r, &minr, &maxr);
2407         retmin = (minl > minr)?minl:minr;
2408         if((maxl != -1) && (maxr != -1))
2409             retmax = (maxl < maxr)?maxl:maxr;
2410         else if(maxl != -1)
2411             retmax = maxl;
2412         else if(maxr != -1)
2413             retmax = maxr;
2414         else
2415             retmax = -1;
2416         break;
2417     case SOP_OR:
2418         findsizelimit(sexpr->l, &minl, &maxl);
2419         findsizelimit(sexpr->r, &minr, &maxr);
2420         retmin = (minl < minr)?minl:minr;
2421         if((maxl == -1) || (maxr == -1))
2422             retmax = -1;
2423         else
2424             retmax = (maxl > maxr)?maxl:maxr;
2425         break;
2426     case SOP_NOT:
2427         findsizelimit(sexpr->l, &minl, &maxl);
2428         if((minl == 0) && (maxl == -1)) /* Interval is unspecified */
2429         {
2430             retmin = 0;
2431             retmax = -1;
2432         } else if((minl == 0) && (maxl != -1)) {
2433             retmin = maxl + 1;
2434             retmax = -1;
2435         } else if((minl != 0) && (maxl == -1)) {
2436             retmin = 0;
2437             retmax = minl - 1;
2438         } else { /* This would yield two seperate intervals, which DC cannot handle */
2439             retmin = 0;
2440             retmax = -1;
2441         }
2442     case SOP_SIZELT:
2443         retmin = 0;
2444         retmax = sexpr->d.n - 1;
2445         break;
2446     case SOP_SIZEEQ:
2447         retmin = sexpr->d.n;
2448         retmax = sexpr->d.n;
2449         break;
2450     case SOP_SIZEGT:
2451         retmin = sexpr->d.n + 1;
2452         retmax = -1;
2453         break;
2454     default:
2455         retmin = 0;
2456         retmax = -1;
2457         break;
2458     }
2459     if(min != NULL)
2460         *min = retmin;
2461     if(max != NULL)
2462         *max = retmax;
2463 }
2464
2465 static struct hash *findsehash(struct sexpr *sexpr)
2466 {
2467     struct hash *h1, *h2;
2468
2469     switch(sexpr->op)
2470     {
2471     case SOP_AND:
2472         if((h1 = findsehash(sexpr->l)) != NULL)
2473             return(h1);
2474         if((h1 = findsehash(sexpr->r)) != NULL)
2475             return(h1);
2476         break;
2477     case SOP_OR:
2478         if((h1 = findsehash(sexpr->l)) == NULL)
2479             return(NULL);
2480         if((h2 = findsehash(sexpr->r)) == NULL)
2481             return(NULL);
2482         if(hashcmp(h1, h2))
2483             return(h1);
2484         break;
2485     case SOP_HASHIS:
2486         if(!wcscmp(sexpr->d.hash->algo, L"TTH"))
2487             return(sexpr->d.hash);
2488     default:
2489         break;
2490     }
2491     return(NULL);
2492 }
2493
2494 static int hubsearch(struct fnetnode *fn, struct search *srch, struct srchfnnlist *ln)
2495 {
2496     struct dchub *hub;
2497     struct wcslist *list, *cur;
2498     char *sstr, *buf, *p;
2499     size_t sstrsize, sstrdata;
2500     struct sockaddr *name;
2501     socklen_t namelen;
2502     int minsize, maxsize;
2503     struct hash *hash;
2504
2505     hub = fn->data;
2506     if((fn->state != FNN_EST) || (hub->sk == NULL) || (hub->sk->state != SOCK_EST))
2507         return(1);
2508     list = findsexprstrs(srch->sexpr);
2509     findsizelimit(srch->sexpr, &minsize, &maxsize);
2510     hash = findsehash(srch->sexpr);
2511     if((minsize != 0) && (maxsize != -1))
2512     {
2513         /* Choose either minsize or maxsize by trying to determine
2514          * which choice will be most restrictive. The result can be
2515          * approximative at best anyway, so don't try too hard... */
2516         if((50000000 - maxsize) > (minsize - 50000000))
2517             minsize = 0;
2518         else
2519             maxsize = -1;
2520     }
2521     sstr = NULL;
2522     sstrsize = sstrdata = 0;
2523     if((hash != NULL) && (hash->len == 24))
2524     {
2525         /* Prioritize hash searches above all else */
2526         bufcat(sstr, "F?T?0?9?TTH:", 12);
2527         buf = base32encode(hash->buf, hash->len);
2528
2529         bufcat(sstr, buf, 39);
2530         free(buf);
2531     } else {
2532         if(minsize != 0)
2533         {
2534             sizebuf2(sstr, sstrdata + 32, 1);
2535             sstrdata += snprintf(sstr + sstrdata, sstrsize - sstrdata, "T?F?%i?1?", minsize);
2536         } else if(maxsize != -1) {
2537             sizebuf2(sstr, sstrdata + 32, 1);
2538             sstrdata += snprintf(sstr + sstrdata, sstrsize - sstrdata, "T?T?%i?1?", maxsize);
2539         } else {
2540             bufcat(sstr, "F?F?0?1?", 8);
2541         }
2542         if(list != NULL)
2543         {
2544             for(cur = list; cur != NULL; cur = cur->next)
2545             {
2546                 /* Use DCCHARSET in $Get paths until further researched... */
2547                 if((buf = icwcstombs(cur->str, DCCHARSET)) == NULL)
2548                 {
2549                     /* Can't find anything anyway if the search expression
2550                      * requires characters outside DC's charset. There's
2551                      * nothing technically wrong with the search itself,
2552                      * however, so return success. This should be
2553                      * considered as an optimization. */
2554                     freesl(&list);
2555                     if(sstr != NULL)
2556                         free(sstr);
2557                     return(0);
2558                 }
2559                 if(cur != list)
2560                     addtobuf(sstr, '$');
2561                 /*
2562                  * It probably doesn't hurt if buf contains any extra
2563                  * dollar signs - it will just result in extra search
2564                  * terms, and the extraneous results will be filtered by
2565                  * the search layer anyway. It hurts if it contains any
2566                  * pipes, though, so let's sell them for money.
2567                  */
2568                 for(p = buf; *p; p++)
2569                 {
2570                     if(*p == '|')
2571                         *p = '$';
2572                 }
2573                 bufcat(sstr, buf, strlen(buf));
2574                 free(buf);
2575             }
2576         } else {
2577             /* Will match all files... :-/ */
2578             addtobuf(sstr, '.');
2579         }
2580     }
2581     addtobuf(sstr, 0);
2582     if(tcpsock != NULL)
2583     {
2584         if(sockgetremotename2(udpsock, hub->sk, &name, &namelen) < 0)
2585         {
2586             flog(LOG_WARNING, "cannot get address of UDP socket");
2587         } else {
2588             qstrf(hub->sk, "$Search %s %s|", formataddress(name, namelen), sstr);
2589             free(name);
2590         }
2591     } else {
2592         qstrf(hub->sk, "$Search Hub:%s %s|", hub->nativenick, sstr);
2593     }
2594     free(sstr);
2595     freesl(&list);
2596     fn->lastsrch = time(NULL);
2597     return(0);
2598 }
2599
2600 #undef skipcmd
2601 #undef qstr
2602 #undef qstrf
2603
2604 #define cc(c) ((void (*)(struct socket *, void *, char *, char *))(c))
2605 static struct command hubcmds[] =
2606 {
2607     {"$Lock", cc(cmd_lock)},
2608     {"$HubName", cc(cmd_hubname)},
2609     {"$Hello", cc(cmd_hello)},
2610     {"$Quit", cc(cmd_quit)},
2611     {"$NickList", cc(cmd_nicklist)},
2612     {"$OpList", cc(cmd_oplist)},
2613     {"$MyINFO", cc(cmd_myinfo)},
2614     {"$ForceMove", cc(cmd_forcemove)},
2615     {"$Search", cc(cmd_search)},
2616     {"$MultiSearch", cc(cmd_search)},
2617     {"$ConnectToMe", cc(cmd_connecttome)},
2618     {"$RevConnectToMe", cc(cmd_revconnecttome)},
2619     {"$GetNetInfo", cc(cmd_getnetinfo)},
2620     {"$To:", cc(cmd_to)},
2621     {"$SR", cc(cmd_sr)},
2622     {"$UserCommand", cc(cmd_usercommand)},
2623     {"$GetPass", cc(cmd_getpass)},
2624     {"$LogedIn", cc(cmd_logedin)}, /* sic */
2625     {"$Supports", cc(cmd_hubsupports)},
2626     {NULL, NULL}
2627 };
2628
2629 static struct command peercmds[] =
2630 {
2631     {"$MyNick", cc(cmd_mynick)},
2632     {"$Lock", cc(cmd_peerlock)},
2633     {"$Direction", cc(cmd_direction)},
2634     {"$Key", cc(cmd_key)},
2635     {"$FileLength", cc(cmd_filelength)},
2636     {"$Error", cc(cmd_error)},
2637     {"$MaxedOut", cc(cmd_maxedout)},
2638     {"$Get", cc(cmd_get)},
2639     {"$Send", cc(cmd_send)},
2640     {"$Supports", cc(cmd_supports)},
2641     {"$GetBlock", cc(cmd_getblock)},
2642     {"$UGetBlock", cc(cmd_getblock)},
2643     {"$GetZBlock", cc(cmd_getblock)},
2644     {"$UGetZBlock", cc(cmd_getblock)},
2645     {"$ADCGET", cc(cmd_adcget)},
2646     {"$ADCSND", cc(cmd_adcsnd), 1},
2647     {"$Sending", cc(cmd_sending), 1},
2648     {NULL, NULL}
2649 };
2650 #undef cc
2651
2652 static void dctransdetach(struct transfer *transfer, struct dcpeer *peer)
2653 {
2654     CBUNREG(transfer, trans_filterout, peer);
2655     if(peer->freeing)
2656         return;
2657     peer->transfer = NULL;
2658     freedcpeer(peer);
2659 }
2660
2661 static void dctransgotdata(struct transfer *transfer, struct dcpeer *peer)
2662 {
2663     int ret;
2664     void *buf;
2665     unsigned char outbuf[1024];
2666     z_stream *cstr;
2667     size_t bufsize;
2668
2669     if((peer->state == PEER_TRNS) || (peer->state == PEER_SYNC))
2670     {
2671         if(sockqueuesize(peer->sk) < 65536)
2672         {
2673             if((buf = transfergetdata(transfer, &bufsize)) != NULL)
2674             {
2675                 if(peer->compress == CPRS_NONE)
2676                 {
2677                     sockqueue(peer->sk, buf, bufsize);
2678                 } else if(peer->compress == CPRS_ZLIB) {
2679                     cstr = peer->cprsdata;
2680                     cstr->next_in = buf;
2681                     cstr->avail_in = bufsize;
2682                     while(cstr->avail_in > 0)
2683                     {
2684                         cstr->next_out = outbuf;
2685                         cstr->avail_out = sizeof(outbuf);
2686                         if((ret = deflate(cstr, 0)) != Z_OK)
2687                         {
2688                             flog(LOG_WARNING, "bug? deflate() did not return Z_OK (but rather %i)", ret);
2689                             freedcpeer(peer);
2690                             return;
2691                         }
2692                         sockqueue(peer->sk, outbuf, sizeof(outbuf) - cstr->avail_out);
2693                     }
2694                 }
2695                 free(buf);
2696             }
2697             if(peer->state == PEER_SYNC)
2698             {
2699                 if(peer->compress == CPRS_ZLIB)
2700                 {
2701                     cstr = peer->cprsdata;
2702                     cstr->next_in = NULL;
2703                     cstr->avail_in = 0;
2704                     do
2705                     {
2706                         cstr->next_out = outbuf;
2707                         cstr->avail_out = sizeof(outbuf);
2708                         ret = deflate(cstr, Z_FINISH);
2709                         if((ret != Z_OK) && (ret != Z_STREAM_END))
2710                         {
2711                             flog(LOG_WARNING, "bug? deflate(Z_FINISH) did not return Z_OK (but rather %i)", ret);
2712                             freedcpeer(peer);
2713                             return;
2714                         }
2715                         sockqueue(peer->sk, outbuf, sizeof(outbuf) - cstr->avail_out);
2716                     } while(ret != Z_STREAM_END);
2717                 }
2718                 if(peer->ptclose)
2719                 {
2720                     freedcpeer(peer);
2721                 } else {
2722                     if(peer->timeout == NULL)
2723                         peer->timeout = timercallback(ntime() + 180, (void (*)(int, void *))peertimeout, peer);
2724                     peer->state = PEER_CMD;
2725                     endcompress(peer);
2726                     transfersetstate(transfer, TRNS_HS);
2727                     socksettos(peer->sk, confgetint("fnet", "fnptos"));
2728                     transfer->flags.b.minislot = 0;
2729                     peer->sk->writecb = NULL;
2730                 }
2731             }
2732         }
2733     }
2734 }
2735
2736 static void dctransendofdata(struct transfer *transfer, struct dcpeer *peer)
2737 {
2738     peer->state = PEER_SYNC;
2739     dctransgotdata(transfer, peer);
2740 }
2741
2742 static void dcwantdata(struct transfer *transfer, struct dcpeer *peer)
2743 {
2744     if(transferdatasize(transfer) < 65536)
2745         peer->sk->ignread = 0;
2746 }
2747
2748 static void transread(struct socket *sk, struct dcpeer *peer)
2749 {
2750     void *buf;
2751     size_t bufsize;
2752     struct transfer *transfer;
2753
2754     if((buf = sockgetinbuf(sk, &bufsize)) == NULL)
2755         return;
2756     if(peer->transfer == NULL)
2757     {
2758         free(buf);
2759         freedcpeer(peer);
2760         return;
2761     }
2762     transferputdata(peer->transfer, buf, bufsize);
2763     free(buf);
2764     if(peer->transfer->curpos >= peer->transfer->size)
2765     {
2766         transfer = peer->transfer;
2767         transferdetach(transfer);
2768         transferendofdata(transfer);
2769         return;
2770     }
2771     if(transferdatasize(peer->transfer) > 65535)
2772         sk->ignread = 1;
2773 }
2774
2775 static void transerr(struct socket *sk, int err, struct dcpeer *peer)
2776 {
2777     struct transfer *transfer;
2778
2779     if((transfer = peer->transfer) == NULL)
2780     {
2781         freedcpeer(peer);
2782         return;
2783     }
2784     transferdetach(transfer);
2785     transferendofdata(transfer);
2786 }
2787
2788 static void transwrite(struct socket *sk, struct dcpeer *peer)
2789 {
2790     if((peer->state != PEER_TRNS) && (peer->state != PEER_SYNC))
2791         return;
2792     if(peer->transfer == NULL)
2793     {
2794         freedcpeer(peer);
2795         return;
2796     }
2797     dctransgotdata(peer->transfer, peer);
2798 }
2799
2800 static void udpread(struct socket *sk, void *data)
2801 {
2802     char *buf, *p, *p2, *hashbuf;
2803     size_t buflen, hashlen;
2804     char *nick, *filename, *hubname;
2805     struct sockaddr_in hubaddr;
2806     int size, slots;
2807     struct fnetnode *fn, *myfn;
2808     struct dchub *hub;
2809     struct srchres *sr;
2810     wchar_t *wnick, *wfile;
2811     struct hash *hash;
2812
2813     if((buf = sockgetinbuf(sk, &buflen)) == NULL)
2814         return;
2815     buf = srealloc(buf, buflen + 1);
2816     buf[buflen] = 0;
2817     if(!strncmp(buf, "$SR ", 4))
2818     {
2819         p = buf + 4;
2820         nick = p;
2821         if((p2 = strchr(p, ' ')) == NULL)
2822         {
2823             free(buf);
2824             return;
2825         }
2826         *p2 = 0;
2827         p = p2 + 1;
2828         filename = p;
2829         if((p2 = strchr(p, 5)) == NULL)
2830         {
2831             free(buf);
2832             return;
2833         }
2834         *p2 = 0;
2835         p = p2 + 1;
2836         if((p2 = strchr(p, ' ')) == NULL)
2837         {
2838             free(buf);
2839             return;
2840         }
2841         *p2 = 0;
2842         size = atoi(p);
2843         p = p2 + 1;
2844         if((p2 = strchr(p, '/')) == NULL)
2845         {
2846             free(buf);
2847             return;
2848         }
2849         *p2 = 0;
2850         slots = atoi(p);
2851         p = p2 + 1;
2852         if((p2 = strchr(p, 5)) == NULL)
2853         {
2854             free(buf);
2855             return;
2856         }
2857         p = p2 + 1;
2858         hubname = p;
2859         if((p2 = strstr(p, " (")) == NULL)
2860         {
2861             free(buf);
2862             return;
2863         }
2864         *p2 = 0;
2865         p = p2 + 2;
2866         if((p2 = strchr(p, ':')) == NULL)
2867         {
2868             free(buf);
2869             return;
2870         }
2871         *(p2++) = 0;
2872         hubaddr.sin_family = AF_INET;
2873         if(!inet_aton(p, &hubaddr.sin_addr))
2874         {
2875             free(buf);
2876             return;
2877         }
2878         p = p2;
2879         if((p2 = strchr(p, ')')) == NULL)
2880         {
2881             free(buf);
2882             return;
2883         }
2884         *p2 = 0;
2885         hubaddr.sin_port = htons(atoi(p));
2886         /* Use DCCHARSET in $Get paths until further researched... */
2887         if((wfile = icmbstowcs(filename, DCCHARSET)) == NULL)
2888         {
2889             free(buf);
2890             return;
2891         }
2892         myfn = NULL;
2893         hash = NULL;
2894         if(!strncmp(hubname, "TTH:", 4))
2895         {
2896             if((hashbuf = base32decode(hubname + 4, &hashlen)) != NULL)
2897             {
2898                 if(hashlen == 24)
2899                     hash = newhash(L"TTH", 24, hashbuf);
2900                 free(hashbuf);
2901             }
2902         } else {
2903             for(fn = fnetnodes; fn != NULL; fn = fn->next)
2904             {
2905                 if((fn->fnet == &dcnet) && ((hub = fn->data) != NULL))
2906                 {
2907                     if((hub->nativename != NULL) && !strcmp(hub->nativename, hubname))
2908                     {
2909                         if(myfn == NULL)
2910                         {
2911                             myfn = fn;
2912                         } else {
2913                             myfn = NULL;
2914                             break;
2915                         }
2916                     }
2917                 }
2918             }
2919         }
2920         if(myfn == NULL)
2921         {
2922             for(fn = fnetnodes; fn != NULL; fn = fn->next)
2923             {
2924                 if((fn->fnet == &dcnet) && ((hub = fn->data) != NULL))
2925                 {
2926                     if((hub->sk != NULL) && addreq(hub->sk->remote, (struct sockaddr *)&hubaddr))
2927                     {
2928                         myfn = fn;
2929                         break;
2930                     }
2931                 }
2932             }
2933         }
2934         hub = NULL;
2935         if(myfn != NULL)
2936             hub = myfn->data;
2937         if((wnick = icmbstowcs(nick, (hub == NULL)?DCCHARSET:(hub->charset))) == NULL)
2938         {
2939             free(buf);
2940             return;
2941         }
2942         sr = newsrchres(&dcnet, wfile, wnick);
2943         if(sr->peernick != NULL)
2944             free(sr->peernick);
2945         sr->peernick = swcsdup(wnick);
2946         sr->size = size;
2947         sr->slots = slots;
2948         free(wfile);
2949         free(wnick);
2950         if(myfn != NULL)
2951             getfnetnode(sr->fn = myfn);
2952         if(hash != NULL)
2953             sr->hash = hash;
2954         submitsrchres(sr);
2955         freesrchres(sr);
2956     }
2957     free(buf);
2958 }
2959
2960 static void hubread(struct socket *sk, struct fnetnode *fn)
2961 {
2962     struct dchub *hub;
2963     char *newbuf;
2964     size_t datalen;
2965     char *p;
2966
2967     hub = (struct dchub *)fn->data;
2968     if((newbuf = sockgetinbuf(sk, &datalen)) == NULL)
2969         return;
2970     if(hub->inbufdata > 500000) /* Discard possible malicious data */
2971         hub->inbufdata = 0;
2972     sizebuf2(hub->inbuf, hub->inbufdata + datalen, 1);
2973     memcpy(hub->inbuf + hub->inbufdata, newbuf, datalen);
2974     free(newbuf);
2975     p = hub->inbuf + hub->inbufdata;
2976     hub->inbufdata += datalen;
2977     while((datalen > 0) && ((p = memchr(p, '|', datalen)) != NULL))
2978     {
2979         *(p++) = 0;
2980         newqcmd(&hub->queue, hub->inbuf);
2981         memmove(hub->inbuf, p, hub->inbufdata -= p - hub->inbuf);
2982         datalen = hub->inbufdata;
2983         p = hub->inbuf;
2984     }
2985 }
2986
2987 static void huberr(struct socket *sk, int err, struct fnetnode *fn)
2988 {
2989     killfnetnode(fn);
2990 }
2991
2992 static int hubsetnick(struct fnetnode *fn, wchar_t *newnick)
2993 {
2994     struct dchub *hub;
2995     char *buf;
2996
2997     hub = fn->data;
2998     if((buf = icwcstombs(newnick, (hub == NULL)?DCCHARSET:(hub->charset))) == NULL)
2999         return(1);
3000     if((strchr(buf, ' ') != NULL) || (strchr(buf, '|') != NULL) || (strchr(buf, '$') != NULL))
3001     {
3002         free(buf);
3003         return(1);
3004     }
3005     if(hub == NULL) /* Not yet connected */
3006     {
3007         free(buf);
3008         return(0);
3009     }
3010     if(hub->nativenick != NULL)
3011         free(hub->nativenick);
3012     hub->nativenick = buf;
3013     return(0);
3014 }
3015
3016 static struct dchub *newdchub(struct fnetnode *fn)
3017 {
3018     struct dchub *new;
3019     wchar_t *emu;
3020     wchar_t *wcharset;
3021     char *charset;
3022
3023     new = smalloc(sizeof(*new));
3024     memset(new, 0, sizeof(*new));
3025     fn->data = new;
3026     if(confgetint("dc", "dcppemu"))
3027         new->dcppemu = 1;
3028     if((emu = wpfind(fn->args, L"dcppemu")) != NULL)
3029     {
3030         if(*emu == L'y')
3031             new->dcppemu = 1;
3032         if(*emu == L'n')
3033             new->dcppemu = 0;
3034     }
3035     charset = NULL;
3036     if((wcharset = wpfind(fn->args, L"charset")) != NULL)
3037     {
3038         if((charset = icwcstombs(wcharset, "US-ASCII")) != NULL)
3039         {
3040             if(!havecharset(charset))
3041             {
3042                 free(charset);
3043                 charset = NULL;
3044             }
3045         }
3046     }
3047     if(charset != NULL)
3048         new->charset = charset;
3049     else
3050         new->charset = sstrdup(DCCHARSET);
3051     if(hubsetnick(fn, fn->mynick))
3052         fnetsetnick(fn, L"DoldaConnectUser-IN");
3053     /* IN as in Invalid Nick */
3054     return(new);
3055 }
3056
3057 static struct dcpeer *newdcpeer(struct socket *sk)
3058 {
3059     struct dcpeer *new;
3060
3061     new = smalloc(sizeof(*new));
3062     memset(new, 0, sizeof(*new));
3063     new->transfer = NULL;
3064     getsock(sk);
3065     new->sk = sk;
3066     if(confgetint("dc", "dcppemu"))
3067         new->dcppemu = 1;
3068     new->next = peers;
3069     new->prev = NULL;
3070     if(peers != NULL)
3071         peers->prev = new;
3072     peers = new;
3073     numdcpeers++;
3074     return(new);
3075 }
3076
3077 static void freedcpeer(struct dcpeer *peer)
3078 {
3079     int i;
3080     struct qcommand *qcmd;
3081
3082     peer->freeing = 1;
3083     if(peers == peer)
3084         peers = peer->next;
3085     if(peer->next != NULL)
3086         peer->next->prev = peer->prev;
3087     if(peer->prev != NULL)
3088         peer->prev->next = peer->next;
3089     if(peer->transfer != NULL)
3090     {
3091         if(peer->transfer->dir == TRNSD_UP)
3092             peer->transfer->close = 1;
3093         if(peer->transfer->dir == TRNSD_DOWN)
3094             resettransfer(peer->transfer);
3095         transferdetach(peer->transfer);
3096     }
3097     if(peer->timeout != NULL)
3098         canceltimer(peer->timeout);
3099     if(peer->sk->data == peer)
3100         peer->sk->data = NULL;
3101     peer->sk->readcb = NULL;
3102     peer->sk->writecb = NULL;
3103     peer->sk->errcb = NULL;
3104     putsock(peer->sk);
3105     endcompress(peer);
3106     if(peer->supports != NULL)
3107     {
3108         for(i = 0; peer->supports[i] != NULL; i++)
3109             free(peer->supports[i]);
3110         free(peer->supports);
3111     }
3112     if(peer->inbuf != NULL)
3113         free(peer->inbuf);
3114     if(peer->key != NULL)
3115         free(peer->key);
3116     if(peer->wcsname != NULL)
3117         free(peer->wcsname);
3118     if(peer->nativename != NULL)
3119         free(peer->nativename);
3120     if(peer->charset != NULL)
3121         free(peer->charset);
3122     if(peer->fn != NULL)
3123         putfnetnode(peer->fn);
3124     while((qcmd = ulqcmd(&peer->queue)) != NULL)
3125         freeqcmd(qcmd);
3126     free(peer);
3127     numdcpeers--;
3128 }
3129
3130 static void hubconnect(struct fnetnode *fn, struct socket *sk)
3131 {
3132     struct dchub *hub;
3133
3134     sk->readcb = (void (*)(struct socket *, void *))hubread;
3135     sk->errcb = (void (*)(struct socket *, int, void *))huberr;
3136     fn->data = hub = newdchub(fn);
3137     sk->data = fn;
3138     getsock(hub->sk = sk);
3139     return;
3140 }
3141
3142 static void hubdestroy(struct fnetnode *fn)
3143 {
3144     int i;
3145     struct dchub *hub;
3146     struct qcommand *qcmd;
3147
3148     hub = (struct dchub *)fn->data;
3149     putsock(hub->sk);
3150     while((qcmd = ulqcmd(&hub->queue)) != NULL)
3151         freeqcmd(qcmd);
3152     if(hub->supports != NULL)
3153     {
3154         for(i = 0; hub->supports[i] != NULL; i++)
3155             free(hub->supports[i]);
3156         free(hub->supports);
3157     }
3158     if(hub->nativename != NULL)
3159         free(hub->nativename);
3160     if(hub->nativenick != NULL)
3161         free(hub->nativenick);
3162     if(hub->charset != NULL)
3163         free(hub->charset);
3164     if(hub->inbuf != NULL)
3165         free(hub->inbuf);
3166     free(hub);
3167 }
3168
3169 static void hubkill(struct fnetnode *fn)
3170 {
3171     struct dchub *hub;
3172
3173     hub = (struct dchub *)fn->data;
3174     hub->sk->close = 1;
3175 }
3176
3177 static wchar_t *dcbasename(wchar_t *filename)
3178 {
3179     wchar_t *ret;
3180
3181     if((ret = wcsrchr(filename, L'\\')) != NULL)
3182         return(ret + 1);
3183     return(filename);
3184 }
3185
3186 static struct transferiface dctransfer =
3187 {
3188     .detach = (void (*)(struct transfer *, void *))dctransdetach,
3189     .gotdata = (void (*)(struct transfer *, void *))dctransgotdata,
3190     .endofdata = (void (*)(struct transfer *, void *))dctransendofdata,
3191     .wantdata = (void (*)(struct transfer *, void *))dcwantdata
3192 };
3193
3194 static struct fnet dcnet =
3195 {
3196     .name = L"dc",
3197     .connect = hubconnect,
3198     .destroy = hubdestroy,
3199     .kill = hubkill,
3200     .setnick = hubsetnick,
3201     .reqconn = hubreqconn,
3202     .sendchat = hubsendchat,
3203     .search = hubsearch,
3204     .filebasename = dcbasename
3205 };
3206
3207 static void peerread(struct socket *sk, struct dcpeer *peer)
3208 {
3209     char *newbuf, *p;
3210     size_t datalen;
3211     struct command *cmd;
3212
3213     if((newbuf = sockgetinbuf(sk, &datalen)) == NULL)
3214         return;
3215     sizebuf2(peer->inbuf, peer->inbufdata + datalen, 1);
3216     memcpy(peer->inbuf + peer->inbufdata, newbuf, datalen);
3217     free(newbuf);
3218     peer->inbufdata += datalen;
3219     if(peer->state == PEER_CMD)
3220     {
3221         p = peer->inbuf;
3222         while((peer->inbufdata > 0) && (p = memchr(peer->inbuf, '|', peer->inbufdata)) != NULL)
3223         {
3224             *(p++) = 0;
3225             newqcmd(&peer->queue, peer->inbuf);
3226             for(cmd = peercmds; cmd->handler != NULL; cmd++)
3227             {
3228                 if(!memcmp(peer->inbuf, cmd->name, strlen(cmd->name)) && ((peer->inbuf[strlen(cmd->name)] == ' ') || (peer->inbuf[strlen(cmd->name)] == '|')))
3229                     break;
3230             }
3231             memmove(peer->inbuf, p, peer->inbufdata -= p - peer->inbuf);
3232             if(cmd->stop)
3233             {
3234                 peer->state = PEER_STOP;
3235                 break;
3236             }
3237         }
3238     } else if(peer->state == PEER_TTHL) {
3239         handletthl(peer);
3240     }
3241 }
3242
3243 static void peererror(struct socket *sk, int err, struct dcpeer *peer)
3244 {
3245     freedcpeer(peer);
3246 }
3247
3248 static void peerconnect(struct socket *sk, int err, struct fnetnode *fn)
3249 {
3250     struct dcpeer *peer;
3251     struct dchub *hub;
3252
3253     if(err != 0)
3254     {
3255         putfnetnode(fn);
3256         putsock(sk);
3257         return;
3258     }
3259     hub = fn->data;
3260     peer = newdcpeer(sk);
3261     peer->fn = fn;
3262     peer->accepted = 0;
3263     peer->dcppemu = hub->dcppemu;
3264     sk->readcb = (void (*)(struct socket *, void *))peerread;
3265     sk->errcb = (void (*)(struct socket *, int, void *))peererror;
3266     sk->data = peer;
3267     socksettos(sk, confgetint("fnet", "fnptos"));
3268     putsock(sk);
3269     peer->timeout = timercallback(ntime() + 180, (void (*)(int, void *))peertimeout, peer);
3270     sendmynick(peer);
3271     sendpeerlock(peer);
3272 }
3273
3274 static void peeraccept(struct socket *sk, struct socket *newsk, void *data)
3275 {
3276     struct dcpeer *peer;
3277
3278     peer = newdcpeer(newsk);
3279     peer->accepted = 1;
3280     newsk->readcb = (void (*)(struct socket *, void *))peerread;
3281     newsk->errcb = (void (*)(struct socket *, int, void *))peererror;
3282     newsk->data = peer;
3283     socksettos(newsk, confgetint("fnet", "fnptos"));
3284     peer->timeout = timercallback(ntime() + 180, (void (*)(int, void *))peertimeout, peer);
3285 }
3286
3287 static void updatehmlist(void)
3288 {
3289     int i, lev, ic, ret;
3290     struct sharecache *node;
3291     char *buf, *buf2, numbuf[32];
3292     size_t bufsize, bufdata;
3293     int fd, ibuf;
3294
3295     bufdata = 0;
3296     buf = smalloc(bufsize = 65536);
3297     node = shareroot->child;
3298     lev = 0;
3299     while(1)
3300     {
3301         ic = 0;
3302         /* Use DCCHARSET in $Get paths until further researched... */
3303         if((buf2 = icwcstombs(node->name, DCCHARSET)) != NULL)
3304         {
3305             for(i = 0; i < lev; i++)
3306                 addtobuf(buf, 9);
3307             bufcat(buf, buf2, strlen(buf2));
3308             free(buf2);
3309             if(node->f.b.type == FILE_REG)
3310             {
3311                 addtobuf(buf, '|');
3312                 sprintf(numbuf, "%zi", node->size);
3313                 bufcat(buf, numbuf, strlen(numbuf));
3314             }
3315             addtobuf(buf, 13);
3316             addtobuf(buf, 10);
3317         } else {
3318             ic = 1;
3319         }
3320         if((node->child != NULL) && !ic)
3321         {
3322             lev++;
3323             node = node->child;
3324         } else if(node->next != NULL) {
3325             node = node->next;
3326         } else {
3327             while(node->next == NULL)
3328             {
3329                 lev--;
3330                 node = node->parent;
3331                 if(node == shareroot)
3332                     break;
3333             }
3334             if(node == shareroot)
3335                 break;
3336             node = node->next;
3337         }
3338     }
3339     if(hmlistname != NULL)
3340     {
3341         unlink(hmlistname);
3342         free(hmlistname);
3343     }
3344     hmlistname = sstrdup("/tmp/dc-filelist-hm-XXXXXX");
3345     if((fd = mkstemp(hmlistname)) < 0)
3346     {
3347         flog(LOG_WARNING, "could not create HM file list tempfile: %s", strerror(errno));
3348         free(hmlistname);
3349         hmlistname = NULL;
3350     } else {
3351         /*
3352          * I do not want to implement a good Huffman encoder, and it's not
3353          * like Huffman encoding actually yields any impressive results
3354          * for DC file lists anyway, so I'll just output a bogus
3355          * tree. Implement a good encoder if you want to.
3356          */
3357         write(fd, "HE3\r\0", 5);
3358         write(fd, &bufdata, 4);
3359         ibuf = 256;
3360         write(fd, &ibuf, 2);
3361         ibuf = 8;
3362         for(i = 0; i < 256; i++)
3363         {
3364             write(fd, &i, 1);
3365             write(fd, &ibuf, 1);
3366         }
3367         for(i = 0; i < 256; i++)
3368             write(fd, &i, 1);
3369         for(buf2 = buf; bufdata > 0;)
3370         {
3371             if((ret = write(fd, buf2, bufdata)) < 0)
3372             {
3373                 flog(LOG_WARNING, "could not write file list: %s", strerror(errno));
3374                 break;
3375             }
3376             bufdata -= ret;
3377             buf2 += ret;
3378         }
3379         close(fd);
3380     }
3381     free(buf);
3382 }
3383
3384 static struct xmlent
3385 {
3386     wchar_t c;
3387     wchar_t *ent;
3388 } entities[] = {
3389     {L'&', L"&amp;"},
3390     {L'\"', L"&#34;"},
3391 /*  {L'\'', L"&quot;"},  Emulate DC++ escaping by omitting this. */
3392     {L'\0', NULL}
3393 };
3394
3395 static wchar_t *escapexml(wchar_t *src)
3396 {
3397     static wchar_t *buf = NULL;;
3398     int ret, c;
3399     wchar_t nbuf[32];
3400     size_t bufsize, bufdata;
3401     struct xmlent *ent;
3402
3403     if(buf != NULL)
3404         free(buf);
3405     buf = NULL;
3406     bufsize = bufdata = 0;
3407     for(; *src != L'\0'; src++)
3408     {
3409         c = wctob(*src);
3410         if((c > 0) && (c < 32))
3411         {
3412             bufcat(buf, L"&#", 2);
3413             ret = swprintf(nbuf, (sizeof(nbuf) / sizeof(*nbuf)), L"%i", c);
3414             bufcat(buf, nbuf, ret);
3415             addtobuf(buf, L';');
3416         } else {
3417             for(ent = entities; ent->ent != NULL; ent++)
3418             {
3419                 if(ent->c == *src)
3420                 {
3421                     bufcat(buf, ent->ent, wcslen(ent->ent));
3422                     break;
3423                 }
3424             }
3425             if(ent->ent == NULL)
3426                 addtobuf(buf, *src);
3427         }
3428     }
3429     addtobuf(buf, L'\0');
3430     return(buf);
3431 }
3432
3433 static void updatexmllist(void)
3434 {
3435     int i, fd, lev;
3436     FILE *fs;
3437     char cidbuf[14], *namebuf;
3438     char *hashbuf;
3439     struct sharecache *node;
3440
3441     if(xmllistname != NULL)
3442     {
3443         unlink(xmllistname);
3444         free(xmllistname);
3445     }
3446     xmllistname = sstrdup("/tmp/dc-filelist-dcxml-XXXXXX");
3447     if((fd = mkstemp(xmllistname)) < 0)
3448     {
3449         flog(LOG_WARNING, "could not create XML file list tempfile: %s", strerror(errno));
3450         free(xmllistname);
3451         xmllistname = NULL;
3452         return;
3453     }
3454     if((fs = fdopen(fd, "w")) == NULL)
3455     {
3456         flog(LOG_WARNING, "could not fdopen XML list fd %i: %s", fd, strerror(errno));
3457         unlink(xmllistname);
3458         free(xmllistname);
3459         xmllistname = NULL;
3460         close(fd);
3461         return;
3462     }
3463     fprintf(fs, "<?xml version=\"1.0\" encoding=\"utf-8\" standalone=\"yes\"?>\r\n");
3464     for(i = 0; i < sizeof(cidbuf) - 1; i++)
3465         cidbuf[i] = (rand() % ('Z' - 'A' + 1)) + 'A';
3466     cidbuf[i] = 0;
3467     if(confgetint("dc", "dcppemu"))
3468         fprintf(fs, "<FileListing Version=\"1\" CID=\"%s\" Base=\"/\" Generator=\"DC++ 0.674\">\r\n", cidbuf);
3469     else
3470         fprintf(fs, "<FileListing Version=\"1\" CID=\"%s\" Base=\"/\" Generator=\"%s\">\r\n", cidbuf, "DoldaConnect" VERSION);
3471
3472     node = shareroot->child;
3473     lev = 0;
3474     while(1)
3475     {
3476         if((namebuf = icswcstombs(escapexml(node->name), "UTF-8", NULL)) != NULL)
3477         {
3478             for(i = 0; i < lev; i++)
3479                 fputc('\t', fs);
3480             if(node->child != NULL)
3481             {
3482                 fprintf(fs, "<Directory Name=\"%s\">\r\n", namebuf);
3483                 node = node->child;
3484                 lev++;
3485                 continue;
3486             } else {
3487                 fprintf(fs, "<File Name=\"%s\" Size=\"%zi\"", namebuf, node->size);
3488                 if(node->f.b.hastth)
3489                 {
3490                     hashbuf = base32encode(node->hashtth, 24);
3491                     fprintf(fs, " TTH=\"%.39s\"", hashbuf);
3492                     free(hashbuf);
3493                 }
3494                 fprintf(fs, "/>\r\n");
3495             }
3496             while(node->next == NULL)
3497             {
3498                 node = node->parent;
3499                 if(node == shareroot)
3500                 {
3501                     break;
3502                 } else {
3503                     lev--;
3504                     for(i = 0; i < lev; i++)
3505                         fputc('\t', fs);
3506                     fprintf(fs, "</Directory>\r\n");
3507                 }
3508             }
3509             if(node == shareroot)
3510                 break;
3511             node = node->next;
3512         }
3513     }
3514
3515     if(confgetint("dc", "dcppemu"))
3516         fprintf(fs, "</FileListing>");
3517     else
3518         fprintf(fs, "</FileListing>\r\n");
3519     fclose(fs);
3520 }
3521
3522 static void updatexmlbz2list(void)
3523 {
3524     int err, fd;
3525     FILE *in;
3526     FILE *real;
3527     BZFILE *out;
3528     char buf[1024];
3529     size_t bufdata;
3530
3531     if(xmllistname == NULL)
3532         return;
3533     if((in = fopen(xmllistname, "r")) == NULL)
3534     {
3535         flog(LOG_WARNING, "could not open XML file list for bzipping: %s", strerror(errno));
3536         return;
3537     }
3538     if(xmlbz2listname != NULL)
3539     {
3540         unlink(xmlbz2listname);
3541         free(xmlbz2listname);
3542     }
3543     xmlbz2listname = sstrdup("/tmp/dc-filelist-dcxmlbz2-XXXXXX");
3544     if((fd = mkstemp(xmlbz2listname)) < 0)
3545     {
3546         flog(LOG_WARNING, "could not create bzipped XML file list tempfile: %s", strerror(errno));
3547         free(xmlbz2listname);
3548         xmlbz2listname = NULL;
3549         fclose(in);
3550         return;
3551     }
3552     if((real = fdopen(fd, "w")) == NULL)
3553     {
3554         flog(LOG_WARNING, "could not fdopen bzipped XML list fd %i: %s", fd, strerror(errno));
3555         close(fd);
3556         unlink(xmlbz2listname);
3557         free(xmlbz2listname);
3558         xmlbz2listname = NULL;
3559         fclose(in);
3560         return;
3561     }
3562     out = BZ2_bzWriteOpen(&err, real, 9, 0, 0);
3563     if(err != BZ_OK)
3564     {
3565         flog(LOG_WARNING, "could not open bzip2 stream from XML list");
3566         fclose(real);
3567         unlink(xmlbz2listname);
3568         free(xmlbz2listname);
3569         xmlbz2listname = NULL;
3570         fclose(in);
3571         return;
3572     }
3573     while(!feof(in))
3574     {
3575         bufdata = fread(buf, 1, sizeof(buf), in);
3576         BZ2_bzWrite(&err, out, buf, bufdata);
3577     }
3578     fclose(in);
3579     BZ2_bzWriteClose(&err, out, 0, NULL, NULL);
3580     fclose(real);
3581 }
3582
3583 static void listtimercb(int cancelled, void *uudata)
3584 {
3585     listwritetimer = NULL;
3586     if(!cancelled)
3587         updatelists(1);
3588 }
3589
3590 static void updatelists(int now)
3591 {
3592     if((hmlistname == NULL) || (xmllistname == NULL) || (xmlbz2listname == NULL))
3593         now = 1;
3594     if(!now)
3595     {
3596         if(listwritetimer == NULL)
3597             listwritetimer = timercallback(ntime() + confgetint("cli", "hashwritedelay"), listtimercb, NULL);
3598         return;
3599     }
3600     if(listwritetimer != NULL)
3601         canceltimer(listwritetimer);
3602     updatehmlist();
3603     updatexmllist();
3604     updatexmlbz2list();
3605 }
3606
3607 static int shareupdate(unsigned long long uusharesize, void *data)
3608 {
3609     updatelists(0);
3610     return(0);
3611 }
3612
3613 static char *quotestr(char *str)
3614 {
3615     unsigned char *buf;
3616     unsigned char *p;
3617     size_t bufsize, bufdata;
3618     wchar_t *wbuf;
3619     static char *enc = NULL;
3620     size_t encsize, encdata;
3621
3622     buf = NULL;
3623     bufsize = bufdata = 0;
3624     for(p = (unsigned char *)str; *p; p++)
3625     {
3626         if(*p == '\b')
3627             bufcat(buf, "\\b", 2);
3628         else if(*p == '\t')
3629             bufcat(buf, "\\t", 2);
3630         else if(*p == '\n')
3631             bufcat(buf, "\\n", 2);
3632         else if(*p == '\r')
3633             bufcat(buf, "\\r", 2);
3634         else if(*p == '\\')
3635             bufcat(buf, "\\\\", 2);
3636         else if(*p >= 32)
3637             addtobuf(buf, *p);
3638         else
3639             bprintf(buf, "\\x%02x", *p);
3640     }
3641     addtobuf(buf, 0);
3642     if(enc != NULL)
3643         free(enc);
3644     enc = NULL;
3645     if((wbuf = icmbstowcs((char *)buf, DCCHARSET)) != NULL)
3646     {
3647         enc = icwcstombs(wbuf, NULL);
3648         free(wbuf);
3649     }
3650     if(enc == NULL)
3651     {
3652         encsize = encdata = 0;
3653         for(p = buf; *p; p++) {
3654             if(*p < 128)
3655                 addtobuf(enc, *p);
3656             else
3657                 bprintf(buf, "\\x%x", *p);
3658         }
3659     }
3660     free(buf);
3661     return(enc);
3662 }
3663
3664 static void logunimpl(char *list, char *cmd, char *args)
3665 {
3666     FILE *log;
3667
3668     if((log = fopen("/tmp/dc-unimpl", "a")) == NULL)
3669     {
3670         flog(LOG_WARNING, "could not open unimpl log: %s", strerror(errno));
3671         return;
3672     }
3673     fputs(list, log);
3674     fputc('\t', log);
3675     fputs(quotestr(cmd), log);
3676     if(args != NULL)
3677     {
3678         fputc('\t', log);
3679         fputs(quotestr(args), log);
3680     }
3681     fputc('\n', log);
3682     fclose(log);
3683 }
3684
3685 static void dispatchcommand(struct qcommand *qcmd, struct command *cmdlist, struct socket *sk, void *data)
3686 {
3687     char *p;
3688     struct command *cmd;
3689
3690     if((p = strchr(qcmd->string, ' ')) != NULL)
3691         *(p++) = 0;
3692     for(cmd = cmdlist; cmd->handler != NULL; cmd++)
3693     {
3694         if(!strcmp(cmd->name, qcmd->string))
3695             break;
3696     }
3697     if(cmd->handler != NULL)
3698     {
3699         cmd->handler(sk, data, qcmd->string, p);
3700     } else if(confgetint("dc", "logunimpl")) {
3701         if(cmdlist == hubcmds)
3702             logunimpl("hub", qcmd->string, p);
3703         else if(cmdlist == peercmds)
3704             logunimpl("peer", qcmd->string, p);
3705         else
3706             logunimpl("other?!", qcmd->string, p);
3707     }
3708 }
3709
3710 static int run(void)
3711 {
3712     struct fnetnode *fn, *nextfn;
3713     struct dchub *hub;
3714     struct dcpeer *peer, *nextpeer;
3715     struct qcommand *qcmd;
3716     int ret;
3717
3718     ret = 0;
3719     for(fn = fnetnodes; fn != NULL; fn = nextfn)
3720     {
3721         nextfn = fn->next;
3722         if(fn->fnet != &dcnet)
3723             continue;
3724         if(fn->data == NULL)
3725             continue;
3726         hub = (struct dchub *)fn->data;
3727         if((qcmd = ulqcmd(&hub->queue)) != NULL)
3728         {
3729             if(*qcmd->string == '$')
3730             {
3731                 if((hub->sk != NULL) && (hub->sk->state == SOCK_EST))
3732                     dispatchcommand(qcmd, hubcmds, hub->sk, fn);
3733             } else if(*qcmd->string != 0) {
3734                 hubrecvchat(hub->sk, fn, NULL, qcmd->string);
3735             }
3736             freeqcmd(qcmd);
3737             ret = 1;
3738             break;
3739         }
3740     }
3741     for(peer = peers; peer != NULL; peer = nextpeer)
3742     {
3743         nextpeer = peer->next;
3744         if((qcmd = ulqcmd(&peer->queue)) != NULL)
3745         {
3746             if(peer->timeout != NULL)
3747                 canceltimer(peer->timeout);
3748             peer->timeout = timercallback(ntime() + 180, (void (*)(int, void *))peertimeout, peer);
3749             if(*qcmd->string == '$')
3750                 dispatchcommand(qcmd, peercmds, peer->sk, peer);
3751             freeqcmd(qcmd);
3752             ret = 1;
3753             break;
3754         }
3755     }
3756     return(ret);
3757 }
3758
3759 static void preinit(int hup)
3760 {
3761     if(hup)
3762         return;
3763     regfnet(&dcnet);
3764 }
3765
3766 static int updateudpport(struct configvar *var, void *uudata)
3767 {
3768     struct sockaddr_in addr;
3769     struct socket *newsock;
3770
3771     memset(&addr, 0, sizeof(addr));
3772     addr.sin_family = AF_INET;
3773     addr.sin_port = htons(var->val.num);
3774     if((newsock = netcsdgram((struct sockaddr *)&addr, sizeof(addr))) == NULL)
3775     {
3776         flog(LOG_WARNING, "could not create new DC UDP socket, reverting to old: %s", strerror(errno));
3777         return(0);
3778     }
3779     newsock->readcb = udpread;
3780     if(udpsock != NULL)
3781         putsock(udpsock);
3782     udpsock = newsock;
3783     return(0);
3784 }
3785
3786 static int updatetcpport(struct configvar *var, void *uudata)
3787 {
3788     struct sockaddr_in addr;
3789     struct socket *newsock;
3790
3791     memset(&addr, 0, sizeof(addr));
3792     addr.sin_family = AF_INET;
3793     addr.sin_port = htons(var->val.num);
3794     if((newsock = netcslisten(SOCK_STREAM, (struct sockaddr *)&addr, sizeof(addr), peeraccept, NULL)) == NULL)
3795         flog(LOG_INFO, "could not listen to a remote address, going into passive mode");
3796     if(tcpsock != NULL)
3797         putsock(tcpsock);
3798     tcpsock = newsock;
3799     return(0);
3800 }
3801
3802 static int init(int hup)
3803 {
3804     struct sockaddr_in addr;
3805
3806     if(!hup)
3807     {
3808         GCBREG(sharechangecb, shareupdate, NULL);
3809         if(udpsock != NULL)
3810             putsock(udpsock);
3811         if(tcpsock != NULL)
3812             putsock(tcpsock);
3813         addr.sin_family = AF_INET;
3814         memset(&addr.sin_addr, 0, sizeof(addr.sin_addr));
3815         addr.sin_port = htons(confgetint("dc", "udpport"));
3816         if((udpsock = netcsdgram((struct sockaddr *)&addr, sizeof(addr))) == NULL)
3817         {
3818             flog(LOG_CRIT, "could not create DC UDP socket: %s", strerror(errno));
3819             return(1);
3820         }
3821         udpsock->readcb = udpread;
3822         addr.sin_port = htons(confgetint("dc", "tcpport"));
3823         if((tcpsock = netcslisten(SOCK_STREAM, (struct sockaddr *)&addr, sizeof(addr), peeraccept, NULL)) == NULL)
3824             flog(LOG_INFO, "could not listen to a remote address, going into passive mode");
3825         CBREG(confgetvar("dc", "udpport"), conf_update, updateudpport, NULL, NULL);
3826         CBREG(confgetvar("dc", "tcpport"), conf_update, updatetcpport, NULL, NULL);
3827         CBREG(confgetvar("net", "mode"), conf_update, updatetcpport, NULL, NULL);
3828     }
3829     return(0);
3830 }
3831
3832 static void terminate(void)
3833 {
3834     if(hmlistname != NULL)
3835     {
3836         unlink(hmlistname);
3837         free(hmlistname);
3838     }
3839     if(xmllistname != NULL)
3840     {
3841         unlink(xmllistname);
3842         free(xmllistname);
3843     }
3844     if(xmlbz2listname != NULL)
3845     {
3846         unlink(xmlbz2listname);
3847         free(xmlbz2listname);
3848     }
3849 }
3850
3851 static struct configvar myvars[] =
3852 {
3853     /** Specifies the share description reported to other DC users. */
3854     {CONF_VAR_STRING, "desc", {.str = L""}},
3855     /** Specifies the speed reported to other DC users. Normal values
3856      * are 28.8Kbps, 33.6Kbps, 56Kbps, Satellite, ISDN, DSL, Cable,
3857      * LAN(T1) or LAN(T3)*/
3858     {CONF_VAR_STRING, "speedstring", {.str = L"LAN(T1)"}},
3859     /** The e-mail address to report to other DC users. */
3860     {CONF_VAR_STRING, "email", {.str = L"spam@spam.org"}},
3861     /** Specifies a specific UDP port to use for DC search results. If
3862      * left unspecified, a port is allocated dynamically. Useful for
3863      * NAT routers (see also the net.visibleipv4 address for those
3864      * cases). */
3865     {CONF_VAR_INT, "udpport", {.num = 0}},
3866     /** Specifies a specific TCP port to use for DC peer
3867      * connections. If left unspecified, a port is allocated
3868      * dynamically. Useful for NAT routers (see also the
3869      * net.visibleipv4 address for those cases). */
3870     {CONF_VAR_INT, "tcpport", {.num = 0}},
3871     /** If set to true, doldacond will do its best to emulate DC++
3872      * (currently v0.674). This should be left off if at all possible,
3873      * since turning it on will violate the rules of most hubs and
3874      * thus give hub owners an actual reason to kick you if it is
3875      * detected. It might be needed for some of the more bone-headed
3876      * hub owners, though. Note that DC++ emulation can also be turned
3877      * on or off for individual hubs, overriding this setting. */
3878     {CONF_VAR_BOOL, "dcppemu", {.num = 0}},
3879     /** Use for debugging. If set to true, doldacond will log all
3880      * unknown commands it receives, and their arguments, to
3881      * /tmp/dc-unimpl. */
3882     {CONF_VAR_BOOL, "logunimpl", {.num = 0}},
3883     {CONF_VAR_END}
3884 };
3885
3886 static struct module me =
3887 {
3888     .conf =
3889     {
3890         .vars = myvars
3891     },
3892     .preinit = preinit,
3893     .init = init,
3894     .run = run,
3895     .terminate = terminate,
3896     .name = "dc"
3897 };
3898
3899 MODULE(me)