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