daemon/transfer.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 <string.h>
  21 #include <time.h>
  22 #include <unistd.h>
  23 #include <fcntl.h>
  24 #include <signal.h>
  25 #include <pwd.h>
  26 #include <grp.h>
  27 #include <errno.h>
  28 #include <sys/wait.h>
  29
  30 #ifdef HAVE_CONFIG_H
  31 #include <config.h>
  32 #endif
  33 #include "log.h"
  34 #include "utils.h"
  35 #include "sysevents.h"
  36 #include "auth.h"
  37 #include "transfer.h"
  38 #include "module.h"
  39 #include "client.h"
  40
  41 static void killfilter(struct transfer *transfer);
  42 static int transferread(struct socket *sk, struct transfer *transfer);
  43 static int transferwrite(struct socket *sk, struct transfer *transfer);
  44 static int transfererr(struct socket *sk, int errno, struct transfer *transfer);
  45 static int filterread(struct socket *sk, struct transfer *transfer);
  46
  47 unsigned long long bytesupload = 0;
  48 unsigned long long bytesdownload = 0;
  49 struct transfer *transfers = NULL;
  50 int numtransfers = 0;
  51 GCBCHAIN(newtransfercb, struct transfer *);
  52
  53 void freetransfer(struct transfer *transfer)
  54 {
  55     if(transfer == transfers)
  56         transfers = transfer->next;
  57     if(transfer->next != NULL)
  58         transfer->next->prev = transfer->prev;
  59     if(transfer->prev != NULL)
  60         transfer->prev->next = transfer->next;
  61     CBCHAINDOCB(transfer, trans_destroy, transfer);
  62     CBCHAINFREE(transfer, trans_ac);
  63     CBCHAINFREE(transfer, trans_act);
  64     CBCHAINFREE(transfer, trans_p);
  65     CBCHAINFREE(transfer, trans_destroy);
  66     CBCHAINFREE(transfer, trans_filterout);
  67     while(transfer->args != NULL)
  68         freewcspair(transfer->args, &transfer->args);
  69     if(transfer->filter != -1)
  70         killfilter(transfer);
  71     if(transfer->etimer != NULL)
  72         canceltimer(transfer->etimer);
  73     if(transfer->auth != NULL)
  74         authputhandle(transfer->auth);
  75     if(transfer->peerid != NULL)
  76         free(transfer->peerid);
  77     if(transfer->peernick != NULL)
  78         free(transfer->peernick);
  79     if(transfer->path != NULL)
  80         free(transfer->path);
  81     if(transfer->actdesc != NULL)
  82         free(transfer->actdesc);
  83     if(transfer->filterbuf != NULL)
  84         free(transfer->filterbuf);
  85     if(transfer->hash != NULL)
  86         freehash(transfer->hash);
  87     if(transfer->exitstatus != NULL)
  88         free(transfer->exitstatus);
  89     if(transfer->localend != NULL)
  90     {
  91         CBUNREG(transfer->localend, socket_read, transferread, transfer);
  92         CBUNREG(transfer->localend, socket_write, transferwrite, transfer);
  93         CBUNREG(transfer->localend, socket_err, transfererr, transfer);
  94         putsock(transfer->localend);
  95     }
  96     if(transfer->filterout != NULL)
  97     {
  98         CBUNREG(transfer->filterout, socket_read, filterread, transfer);
  99         putsock(transfer->filterout);
 100     }
 101     if(transfer->fn != NULL)
 102         putfnetnode(transfer->fn);
 103     free(transfer);
 104     numtransfers--;
 105 }
 106
 107 struct transfer *newtransfer(void)
 108 {
 109     struct transfer *new;
 110     static int curid = 0;
 111
 112     new = smalloc(sizeof(*new));
 113     memset(new, 0, sizeof(*new));
 114     new->id = curid++;
 115     new->size = -1;
 116     new->endpos = -1;
 117     new->filter = -1;
 118     CBCHAININIT(new, trans_ac);
 119     CBCHAININIT(new, trans_act);
 120     CBCHAININIT(new, trans_p);
 121     CBCHAININIT(new, trans_destroy);
 122     CBCHAININIT(new, trans_filterout);
 123     new->next = NULL;
 124     new->prev = NULL;
 125     time(&new->activity);
 126     numtransfers++;
 127     return(new);
 128 }
 129
 130 void transferattach(struct transfer *transfer, struct transferiface *iface, void *data)
 131 {
 132     if(transfer->iface != NULL)
 133         transferdetach(transfer);
 134     transfer->iface = iface;
 135     transfer->ifacedata = data;
 136 }
 137
 138 void transferdetach(struct transfer *transfer)
 139 {
 140     if(transfer->iface != NULL)
 141     {
 142         transfer->iface->detach(transfer, transfer->ifacedata);
 143         transfer->iface = NULL;
 144         transfer->ifacedata = NULL;
 145     }
 146 }
 147
 148 struct transfer *finddownload(wchar_t *peerid)
 149 {
 150     struct transfer *transfer;
 151
 152     for(transfer = transfers; transfer != NULL; transfer = transfer->next)
 153     {
 154         if((transfer->dir == TRNSD_DOWN) && (transfer->iface == NULL) && !wcscmp(peerid, transfer->peerid))
 155             break;
 156     }
 157     return(transfer);
 158 }
 159
 160 struct transfer *hasupload(struct fnet *fnet, wchar_t *peerid)
 161 {
 162     struct transfer *transfer;
 163
 164     for(transfer = transfers; transfer != NULL; transfer = transfer->next)
 165     {
 166         if((transfer->dir == TRNSD_UP) && (transfer->fnet == fnet) && !wcscmp(transfer->peerid, peerid))
 167             break;
 168     }
 169     return(transfer);
 170 }
 171
 172 struct transfer *newupload(struct fnetnode *fn, struct fnet *fnet, wchar_t *nickid, struct transferiface *iface, void *data)
 173 {
 174     struct transfer *transfer;
 175
 176     transfer = newtransfer();
 177     if(fnet != NULL)
 178         transfer->fnet = fnet;
 179     else
 180         transfer->fnet = fn->fnet;
 181     transfer->peerid = swcsdup(nickid);
 182     transfer->state = TRNS_HS;
 183     transfer->dir = TRNSD_UP;
 184     if(fn != NULL)
 185         getfnetnode(transfer->fn = fn);
 186     transferattach(transfer, iface, data);
 187     linktransfer(transfer);
 188     bumptransfer(transfer);
 189     return(transfer);
 190 }
 191
 192 void linktransfer(struct transfer *transfer)
 193 {
 194     transfer->next = transfers;
 195     transfer->prev = NULL;
 196     if(transfers != NULL)
 197         transfers->prev = transfer;
 198     transfers = transfer;
 199     GCBCHAINDOCB(newtransfercb, transfer);
 200 }
 201
 202 void resettransfer(struct transfer *transfer)
 203 {
 204     if(transfer->dir == TRNSD_DOWN)
 205     {
 206         if(transfer->iface != NULL)
 207             transferdetach(transfer);
 208         killfilter(transfer);
 209         transfersetstate(transfer, TRNS_WAITING);
 210         transfersetactivity(transfer, L"reset");
 211         return;
 212     }
 213 }
 214
 215 struct transfer *findtransfer(int id)
 216 {
 217     struct transfer *transfer;
 218
 219     for(transfer = transfers; transfer != NULL; transfer = transfer->next)
 220     {
 221         if(transfer->id == id)
 222             break;
 223     }
 224     return(transfer);
 225 }
 226
 227 static void transexpire(int cancelled, struct transfer *transfer)
 228 {
 229     transfer->etimer = NULL;
 230     if(!cancelled)
 231         bumptransfer(transfer);
 232     else
 233         transfer->timeout = 0;
 234 }
 235
 236 static int transferread(struct socket *sk, struct transfer *transfer)
 237 {
 238     if(sockgetdatalen(sk) >= 65536)
 239         sk->ignread = 1;
 240     if((transfer->iface != NULL) && (transfer->iface->gotdata != NULL))
 241         transfer->iface->gotdata(transfer, transfer->ifacedata);
 242     return(0);
 243 }
 244
 245 static int transferwrite(struct socket *sk, struct transfer *transfer)
 246 {
 247     if((transfer->iface != NULL) && (transfer->iface->wantdata != NULL))
 248         transfer->iface->wantdata(transfer, transfer->ifacedata);
 249     return(0);
 250 }
 251
 252 static int transfererr(struct socket *sk, int errno, struct transfer *transfer)
 253 {
 254     if((transfer->iface != NULL) && (transfer->iface->endofdata != NULL))
 255         transfer->iface->endofdata(transfer, transfer->ifacedata);
 256     return(0);
 257 }
 258
 259 void transferputdata(struct transfer *transfer, void *buf, size_t size)
 260 {
 261     time(&transfer->activity);
 262     sockqueue(transfer->localend, buf, size);
 263     transfer->curpos += size;
 264     bytesdownload += size;
 265     CBCHAINDOCB(transfer, trans_p, transfer);
 266 }
 267
 268 void transferendofdata(struct transfer *transfer)
 269 {
 270     if(transfer->curpos >= transfer->size)
 271     {
 272         transfersetstate(transfer, TRNS_DONE);
 273         CBUNREG(transfer->localend, socket_read, transferread, transfer);
 274         CBUNREG(transfer->localend, socket_write, transferwrite, transfer);
 275         CBUNREG(transfer->localend, socket_err, transfererr, transfer);
 276         putsock(transfer->localend);
 277         transfer->localend = NULL;
 278     } else {
 279         resettransfer(transfer);
 280     }
 281 }
 282
 283 size_t transferdatasize(struct transfer *transfer)
 284 {
 285     return(sockqueuesize(transfer->localend));
 286 }
 287
 288 void *transfergetdata(struct transfer *transfer, size_t *size)
 289 {
 290     void *buf;
 291
 292     if(transfer->localend == NULL)
 293         return(NULL);
 294     transfer->localend->ignread = 0;
 295     time(&transfer->activity);
 296     if((buf = sockgetinbuf(transfer->localend, size)) == NULL)
 297         return(NULL);
 298     if((transfer->endpos >= 0) && (transfer->curpos + *size >= transfer->endpos))
 299     {
 300         *size = transfer->endpos - transfer->curpos;
 301         buf = srealloc(buf, *size);
 302     }
 303     transfer->curpos += *size;
 304     bytesupload += *size;
 305     CBCHAINDOCB(transfer, trans_p, transfer);
 306     return(buf);
 307 }
 308
 309 void transferprepul(struct transfer *transfer, size_t size, size_t start, size_t end, struct socket *lesk)
 310 {
 311     transfersetsize(transfer, size);
 312     transfer->curpos = start;
 313     transfer->endpos = end;
 314     lesk->ignread = 1;
 315     transfersetlocalend(transfer, lesk);
 316 }
 317
 318 void transferstartdl(struct transfer *transfer, struct socket *sk)
 319 {
 320     transfersetstate(transfer, TRNS_MAIN);
 321     socksettos(sk, confgetint("transfer", "dltos"));
 322 }
 323
 324 void transferstartul(struct transfer *transfer, struct socket *sk)
 325 {
 326     transfersetstate(transfer, TRNS_MAIN);
 327     socksettos(sk, confgetint("transfer", "ultos"));
 328     if(transfer->localend != NULL)
 329         transfer->localend->ignread = 0;
 330 }
 331
 332 void transfersetlocalend(struct transfer *transfer, struct socket *sk)
 333 {
 334     if(transfer->localend != NULL)
 335         putsock(transfer->localend);
 336     getsock(transfer->localend = sk);
 337     CBREG(sk, socket_read, (int (*)(struct socket *, void *))transferread, NULL, transfer);
 338     CBREG(sk, socket_write, (int (*)(struct socket *, void *))transferwrite, NULL, transfer);
 339     CBREG(sk, socket_err, (int (*)(struct socket *, int, void *))transfererr, NULL, transfer);
 340 }
 341
 342 static int tryreq(struct transfer *transfer)
 343 {
 344     struct fnetnode *fn;
 345     struct fnetpeer *peer;
 346
 347     if((fn = transfer->fn) != NULL)
 348     {
 349         if(fn->state != FNN_EST)
 350         {
 351             transfer->close = 1;
 352             return(1);
 353         }
 354         peer = fnetfindpeer(fn, transfer->peerid);
 355     } else {
 356         peer = NULL;
 357         for(fn = fnetnodes; fn != NULL; fn = fn->next)
 358         {
 359             if((fn->state == FNN_EST) && (fn->fnet == transfer->fnet) && ((peer = fnetfindpeer(fn, transfer->peerid)) != NULL))
 360                 break;
 361         }
 362     }
 363     if(peer != NULL)
 364     {
 365         time(&transfer->lastreq);
 366         return(fn->fnet->reqconn(peer));
 367     }
 368     return(1);
 369 }
 370
 371 void trytransferbypeer(struct fnet *fnet, wchar_t *peerid)
 372 {
 373     struct transfer *transfer;
 374
 375     for(transfer = transfers; transfer != NULL; transfer = transfer->next)
 376     {
 377         if((transfer->dir == TRNSD_DOWN) && (transfer->state == TRNS_WAITING))
 378         {
 379             if((transfer->fnet == fnet) && !wcscmp(transfer->peerid, peerid))
 380             {
 381                 if(!tryreq(transfer))
 382                     return;
 383             }
 384         }
 385     }
 386 }
 387
 388 void bumptransfer(struct transfer *transfer)
 389 {
 390     time_t now;
 391
 392     if((now = time(NULL)) < transfer->timeout)
 393     {
 394
 395         if(transfer->etimer == NULL)
 396             transfer->etimer = timercallback(transfer->timeout, (void (*)(int, void *))transexpire, transfer);
 397         return;
 398     }
 399     if(transfer->etimer != NULL)
 400         canceltimer(transfer->etimer);
 401     switch(transfer->state)
 402     {
 403     case TRNS_WAITING:
 404         transfer->etimer = timercallback(transfer->timeout = (time(NULL) + 30), (void (*)(int, void *))transexpire, transfer);
 405         if(now - transfer->lastreq > 30)
 406             tryreq(transfer);
 407         break;
 408     case TRNS_HS:
 409         if(transfer->dir == TRNSD_UP)
 410         {
 411             if(now - transfer->activity < 60)
 412                 transfer->etimer = timercallback(transfer->timeout = (time(NULL) + 60), (void (*)(int, void *))transexpire, transfer);
 413             else
 414                 transfer->close = 1;
 415         } else if(transfer->dir == TRNSD_DOWN) {
 416             if(now - transfer->activity < 60)
 417                 transfer->etimer = timercallback(transfer->timeout = (time(NULL) + 60), (void (*)(int, void *))transexpire, transfer);
 418             else
 419                 resettransfer(transfer);
 420         }
 421         break;
 422     case TRNS_MAIN:
 423         if(transfer->dir == TRNSD_UP)
 424         {
 425             if(now - transfer->activity < 300)
 426                 transfer->etimer = timercallback(transfer->timeout = (time(NULL) + 300), (void (*)(int, void *))transexpire, transfer);
 427             else
 428                 transfer->close = 1;
 429         }
 430         break;
 431     }
 432 }
 433
 434 void transfersetactivity(struct transfer *transfer, wchar_t *desc)
 435 {
 436     time(&transfer->activity);
 437     if(desc != NULL)
 438     {
 439         if(transfer->actdesc != NULL)
 440             free(transfer->actdesc);
 441         transfer->actdesc = swcsdup(desc);
 442     }
 443     bumptransfer(transfer);
 444     CBCHAINDOCB(transfer, trans_act, transfer);
 445 }
 446
 447 void transfersetstate(struct transfer *transfer, int newstate)
 448 {
 449     transfer->state = newstate;
 450     if(transfer->etimer != NULL)
 451         canceltimer(transfer->etimer);
 452     transfersetactivity(transfer, NULL);
 453     CBCHAINDOCB(transfer, trans_ac, transfer, L"state");
 454 }
 455
 456 void transfersetnick(struct transfer *transfer, wchar_t *newnick)
 457 {
 458     if(transfer->peernick != NULL)
 459         free(transfer->peernick);
 460     transfer->peernick = swcsdup(newnick);
 461     CBCHAINDOCB(transfer, trans_ac, transfer, L"nick");
 462 }
 463
 464 void transfersetsize(struct transfer *transfer, int newsize)
 465 {
 466     transfer->size = newsize;
 467     CBCHAINDOCB(transfer, trans_ac, transfer, L"size");
 468 }
 469
 470 void transferseterror(struct transfer *transfer, int error)
 471 {
 472     transfer->error = error;
 473     CBCHAINDOCB(transfer, trans_ac, transfer, L"error");
 474 }
 475
 476 void transfersetpath(struct transfer *transfer, wchar_t *path)
 477 {
 478     if(transfer->path != NULL)
 479         free(transfer->path);
 480     transfer->path = swcsdup(path);
 481     CBCHAINDOCB(transfer, trans_ac, transfer, L"path");
 482 }
 483
 484 void transfersethash(struct transfer *transfer, struct hash *hash)
 485 {
 486     if(transfer->hash != NULL)
 487         freehash(transfer->hash);
 488     transfer->hash = hash;
 489     CBCHAINDOCB(transfer, trans_ac, transfer, L"hash");
 490 }
 491
 492 int slotsleft(void)
 493 {
 494     struct transfer *transfer;
 495     int slots;
 496
 497     slots = confgetint("transfer", "slots");
 498     for(transfer = transfers; (transfer != NULL) && (slots > 0); transfer = transfer->next)
 499     {
 500         if((transfer->dir == TRNSD_UP) && (transfer->state == TRNS_MAIN) && !transfer->flags.b.minislot)
 501             slots--;
 502     }
 503     return(slots);
 504 }
 505
 506 static void killfilter(struct transfer *transfer)
 507 {
 508     if(transfer->filter != -1)
 509     {
 510         kill(-transfer->filter, SIGHUP);
 511         transfer->filter = -1;
 512     }
 513     if(transfer->localend)
 514     {
 515         CBUNREG(transfer->localend, socket_read, transferread, transfer);
 516         CBUNREG(transfer->localend, socket_write, transferwrite, transfer);
 517         CBUNREG(transfer->localend, socket_err, transfererr, transfer);
 518         putsock(transfer->localend);
 519         transfer->localend = NULL;
 520     }
 521     if(transfer->filterout)
 522     {
 523         CBUNREG(transfer->filterout, socket_read, filterread, transfer);
 524         putsock(transfer->filterout);
 525         transfer->filterout = NULL;
 526     }
 527     if(transfer->filterbuf)
 528     {
 529         free(transfer->filterbuf);
 530         transfer->filterbuf = NULL;
 531     }
 532     transfer->filterbufsize = transfer->filterbufdata = 0;
 533 }
 534
 535 static char *findfilter(struct passwd *pwd)
 536 {
 537     char *path, *filtername;
 538
 539     if((path = sprintf2("%s/.dcdl-filter", pwd->pw_dir)) != NULL)
 540     {
 541         if(!access(path, X_OK))
 542             return(path);
 543         free(path);
 544     }
 545     if((filtername = icwcstombs(confgetstr("transfer", "filter"), NULL)) == NULL)
 546     {
 547         flog(LOG_WARNING, "could not convert filter name into local charset: %s", strerror(errno));
 548     } else {
 549         if(strchr(filtername, '/') == NULL)
 550         {
 551             if((path = sprintf2("/etc/%s", filtername)) != NULL)
 552             {
 553                 if(!access(path, X_OK))
 554                 {
 555                     free(filtername);
 556                     return(path);
 557                 }
 558                 free(path);
 559             }
 560             if((path = sprintf2("/usr/etc/%s", filtername)) != NULL)
 561             {
 562                 if(!access(path, X_OK))
 563                 {
 564                     free(filtername);
 565                     return(path);
 566                 }
 567                 free(path);
 568             }
 569             if((path = sprintf2("/usr/local/etc/%s", filtername)) != NULL)
 570             {
 571                 if(!access(path, X_OK))
 572                 {
 573                     free(filtername);
 574                     return(path);
 575                 }
 576                 free(path);
 577             }
 578         } else {
 579             if(!access(filtername, X_OK))
 580                 return(filtername);
 581         }
 582         free(filtername);
 583     }
 584     return(NULL);
 585 }
 586
 587 static void handletranscmd(struct transfer *transfer, wchar_t *cmd, wchar_t *arg)
 588 {
 589     if(!wcscmp(cmd, L"status")) {
 590         if(arg == NULL)
 591             arg = L"";
 592         if(transfer->exitstatus != NULL)
 593             free(transfer->exitstatus);
 594         transfer->exitstatus = swcsdup(arg);
 595     }
 596 }
 597
 598 static int filterread(struct socket *sk, struct transfer *transfer)
 599 {
 600     char *buf, *p, *p2;
 601     size_t bufsize;
 602     wchar_t *cmd, *arg;
 603
 604     if((buf = sockgetinbuf(sk, &bufsize)) == NULL)
 605         return(0);
 606     bufcat(transfer->filterbuf, buf, bufsize);
 607     free(buf);
 608     while((p = memchr(transfer->filterbuf, '\n', transfer->filterbufdata)) != NULL)
 609     {
 610         *(p++) = 0;
 611         if((p2 = strchr(transfer->filterbuf, ' ')) != NULL)
 612             *(p2++) = 0;
 613         if((cmd = icmbstowcs(transfer->filterbuf, NULL)) != NULL)
 614         {
 615             arg = NULL;
 616             if(p2 != NULL)
 617             {
 618                 if((arg = icmbstowcs(p2, NULL)) == NULL)
 619                     flog(LOG_WARNING, "filter sent a string which could not be converted into the local charset: %s: %s", p2, strerror(errno));
 620             }
 621             handletranscmd(transfer, cmd, arg);
 622             CBCHAINDOCB(transfer, trans_filterout, transfer, cmd, arg);
 623             if(arg != NULL)
 624                 free(arg);
 625             free(cmd);
 626         } else {
 627             flog(LOG_WARNING, "filter sent a string which could not be converted into the local charset: %s: %s", transfer->filterbuf, strerror(errno));
 628         }
 629         memmove(transfer->filterbuf, p, transfer->filterbufdata -= (p - transfer->filterbuf));
 630     }
 631     return(0);
 632 }
 633
 634 static void filterexit(pid_t pid, int status, void *data)
 635 {
 636     struct transfer *transfer;
 637     struct fnet *fnet;
 638     wchar_t *peerid;
 639
 640     for(transfer = transfers; transfer != NULL; transfer = transfer->next)
 641     {
 642         if(transfer->filter == pid)
 643         {
 644             transfer->filter = -1;
 645             killfilter(transfer);
 646             fnet = transfer->fnet;
 647             peerid = swcsdup(transfer->peerid);
 648             if(WEXITSTATUS(status))
 649                 resettransfer(transfer);
 650             else
 651                 freetransfer(transfer);
 652             trytransferbypeer(fnet, peerid);
 653             free(peerid);
 654             break;
 655         }
 656     }
 657 }
 658
 659 int forkfilter(struct transfer *transfer)
 660 {
 661     char *filtername, *filename, *peerid, *buf;
 662     wchar_t *wfilename;
 663     struct passwd *pwent;
 664     pid_t pid;
 665     int inpipe, outpipe;
 666     char **argv;
 667     size_t argvsize, argvdata;
 668     struct socket *insock, *outsock;
 669     struct wcspair *ta;
 670     char *rec, *val;
 671
 672     wfilename = transfer->path;
 673     if(transfer->fnet->filebasename != NULL)
 674         wfilename = transfer->fnet->filebasename(wfilename);
 675     if(transfer->auth == NULL)
 676     {
 677         flog(LOG_WARNING, "tried to fork filter for transfer with NULL authhandle (tranfer %i)", transfer->id);
 678         errno = EACCES;
 679         return(-1);
 680     }
 681     if((pwent = getpwuid(transfer->owner)) == NULL)
 682     {
 683         flog(LOG_WARNING, "no passwd entry for uid %i (found in transfer %i)", transfer->owner, transfer->id);
 684         errno = EACCES;
 685         return(-1);
 686     }
 687     if((filtername = findfilter(pwent)) == NULL)
 688     {
 689         flog(LOG_WARNING, "could not find filter for user %s", pwent->pw_name);
 690         errno = ENOENT;
 691         return(-1);
 692     }
 693     if((filename = icwcstombs(wfilename, NULL)) == NULL)
 694     {
 695         if((buf = icwcstombs(wfilename, "UTF-8")) == NULL)
 696         {
 697             flog(LOG_WARNING, "could convert transfer filename to neither local charset nor UTF-8: %s", strerror(errno));
 698             return(-1);
 699         }
 700         filename = sprintf2("utf8-%s", buf);
 701         free(buf);
 702     }
 703     if((peerid = icwcstombs(transfer->peerid, NULL)) == NULL)
 704     {
 705         if((buf = icwcstombs(transfer->peerid, "UTF-8")) == NULL)
 706         {
 707             flog(LOG_WARNING, "could convert transfer peerid to neither local charset nor UTF-8: %s", strerror(errno));
 708             free(filename);
 709             return(-1);
 710         }
 711         peerid = sprintf2("utf8-%s", buf);
 712         free(buf);
 713     }
 714     if((pid = forksess(transfer->owner, transfer->auth, filterexit, NULL, FD_PIPE, 0, O_WRONLY, &inpipe, FD_PIPE, 1, O_RDONLY, &outpipe, FD_FILE, 2, O_RDWR, "/dev/null", FD_END)) < 0)
 715     {
 716         flog(LOG_WARNING, "could not fork session for filter for transfer %i: %s", transfer->id, strerror(errno));
 717         return(-1);
 718     }
 719     if(pid == 0)
 720     {
 721         argv = NULL;
 722         argvsize = argvdata = 0;
 723         buf = sprintf2("%i", transfer->size);
 724         addtobuf(argv, filtername);
 725         addtobuf(argv, filename);
 726         addtobuf(argv, buf);
 727         addtobuf(argv, peerid);
 728         if(transfer->hash)
 729         {
 730             if((buf = icwcstombs(unparsehash(transfer->hash), NULL)) != NULL)
 731             {
 732                 /* XXX: I am very doubtful of this, but it can just as
 733                  * well be argued that all data should be presented as
 734                  * key-value pairs. */
 735                 addtobuf(argv, "hash");
 736                 addtobuf(argv, buf);
 737             } else {
 738                 flog(LOG_WARNING, "could not convert hash to local charset");
 739             }
 740         }
 741         for(ta = transfer->args; ta != NULL; ta = ta->next)
 742         {
 743             if((rec = icwcstombs(ta->key, NULL)) == NULL)
 744                 continue;
 745             if((val = icwcstombs(ta->val, NULL)) == NULL)
 746                 continue;
 747             addtobuf(argv, rec);
 748             addtobuf(argv, val);
 749         }
 750         addtobuf(argv, NULL);
 751         execv(filtername, argv);
 752         flog(LOG_WARNING, "could not exec filter %s: %s", filtername, strerror(errno));
 753         exit(127);
 754     }
 755     insock = wrapsock(inpipe);
 756     outsock = wrapsock(outpipe);
 757     /* Really, really strange thing here - sometimes the kernel would
 758      * return POLLIN on insock, even though it's a write-side
 759      * pipe. The corresponding read on the pipe naturally returns
 760      * EBADF, causing doldacond to think there's something wrong with
 761      * the fd, and thus it closes it. Until I can find out whyever the
 762      * kernel gives a POLLIN on the fd (if I can at all...), I'll just
 763      * set ignread on insock for now. */
 764     insock->ignread = 1;
 765     transfer->filter = pid;
 766     transfersetlocalend(transfer, insock);
 767     getsock(transfer->filterout = outsock);
 768     CBREG(outsock, socket_read, (int (*)(struct socket *, void *))filterread, NULL, transfer);
 769     putsock(insock);
 770     putsock(outsock);
 771     free(filtername);
 772     free(filename);
 773     free(peerid);
 774     return(0);
 775 }
 776
 777 static int run(void)
 778 {
 779     struct transfer *transfer, *next;
 780
 781     for(transfer = transfers; transfer != NULL; transfer = transfer->next)
 782     {
 783         if((transfer->endpos >= 0) && (transfer->state == TRNS_MAIN) && (transfer->localend != NULL) && (transfer->localend->state == SOCK_EST) && (transfer->curpos >= transfer->endpos))
 784         {
 785             if((transfer->iface != NULL) && (transfer->iface->endofdata != NULL))
 786                 transfer->iface->endofdata(transfer, transfer->ifacedata);
 787             closesock(transfer->localend);
 788         }
 789     }
 790     for(transfer = transfers; transfer != NULL; transfer = next)
 791     {
 792         next = transfer->next;
 793         if(transfer->close)
 794         {
 795             transferdetach(transfer);
 796             freetransfer(transfer);
 797             continue;
 798         }
 799     }
 800     return(0);
 801 }
 802
 803 static struct configvar myvars[] =
 804 {
 805     {CONF_VAR_INT, "slots", {.num = 3}},
 806     {CONF_VAR_INT, "ultos", {.num = SOCK_TOS_MAXTP}},
 807     {CONF_VAR_INT, "dltos", {.num = SOCK_TOS_MAXTP}},
 808     {CONF_VAR_STRING, "filter", {.str = L"dc-filter"}},
 809     {CONF_VAR_BOOL, "ulquota", {.num = 0}},
 810     {CONF_VAR_END}
 811 };
 812
 813 static struct module me =
 814 {
 815     .conf =
 816     {
 817         .vars = myvars
 818     },
 819     .name = "transfer",
 820     .run = run
 821 };
 822
 823 MODULE(me);