[doldaconnect.git] / daemon / transfer.c

/*
 *  Dolda Connect - Modular multiuser Direct Connect-style client
 *  Copyright (C) 2004 Fredrik Tolf (fredrik@dolda2000.com)
 *  
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *  
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *  
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>
#include <fcntl.h>
#include <signal.h>
#include <pwd.h>
#include <grp.h>
#include <errno.h>
#include <sys/wait.h>

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "log.h"
#include "utils.h"
#include "sysevents.h"
#include "auth.h"
#include "transfer.h"
#include "module.h"

static void killfilter(struct transfer *transfer);

struct transfer *transfers = NULL;
int numtransfers = 0;
GCBCHAIN(newtransfercb, struct transfer *);

void freetransfer(struct transfer *transfer)
{
    struct transarg *ta;
    
    if(transfer == transfers)
	transfers = transfer->next;
    if(transfer->next != NULL)
	transfer->next->prev = transfer->prev;
    if(transfer->prev != NULL)
	transfer->prev->next = transfer->next;
    CBCHAINDOCB(transfer, trans_destroy, transfer);
    CBCHAINFREE(transfer, trans_ac);
    CBCHAINFREE(transfer, trans_act);
    CBCHAINFREE(transfer, trans_p);
    CBCHAINFREE(transfer, trans_destroy);
    CBCHAINFREE(transfer, trans_filterout);
    while((ta = transfer->args) != NULL)
    {
	transfer->args = ta->next;
	free(ta->rec);
	free(ta->val);
	free(ta);
    }
    if(transfer->filter != -1)
	killfilter(transfer);
    if(transfer->etimer != NULL)
	canceltimer(transfer->etimer);
    if(transfer->auth != NULL)
	authputhandle(transfer->auth);
    if(transfer->peerid != NULL)
	free(transfer->peerid);
    if(transfer->peernick != NULL)
	free(transfer->peernick);
    if(transfer->path != NULL)
	free(transfer->path);
    if(transfer->actdesc != NULL)
	free(transfer->actdesc);
    if(transfer->filterbuf != NULL)
	free(transfer->filterbuf);
    if(transfer->localend != NULL)
    {
	transfer->localend->readcb = NULL;
	transfer->localend->writecb = NULL;
	transfer->localend->errcb = NULL;
	putsock(transfer->localend);
    }
    if(transfer->filterout != NULL)
    {
	transfer->filterout->readcb = NULL;
	transfer->filterout->writecb = NULL;
	transfer->filterout->errcb = NULL;
	putsock(transfer->filterout);
    }
    if(transfer->fn != NULL)
	putfnetnode(transfer->fn);
    free(transfer);
    numtransfers--;
}

struct transfer *newtransfer(void)
{
    struct transfer *new;
    static int curid = 0;
    
    new = smalloc(sizeof(*new));
    memset(new, 0, sizeof(*new));
    new->id = curid++;
    new->size = -1;
    new->endpos = -1;
    new->filter = -1;
    CBCHAININIT(new, trans_ac);
    CBCHAININIT(new, trans_act);
    CBCHAININIT(new, trans_p);
    CBCHAININIT(new, trans_destroy);
    CBCHAININIT(new, trans_filterout);
    new->next = NULL;
    new->prev = NULL;
    time(&new->activity);
    numtransfers++;
    return(new);
}

void transferaddarg(struct transfer *transfer, wchar_t *rec, wchar_t *val)
{
    struct transarg *ta;
    
    ta = smalloc(sizeof(*ta));
    ta->rec = swcsdup(rec);
    ta->val = swcsdup(val);
    ta->next = transfer->args;
    transfer->args = ta;
}

void transferattach(struct transfer *transfer, struct transferiface *iface, void *data)
{
    if(transfer->iface != NULL)
	transferdetach(transfer);
    transfer->iface = iface;
    transfer->ifacedata = data;
}

void transferdetach(struct transfer *transfer)
{
    if(transfer->iface != NULL)
    {
	transfer->iface->detach(transfer, transfer->ifacedata);
	transfer->iface = NULL;
	transfer->ifacedata = NULL;
    }
}

struct transfer *newupload(struct fnetnode *fn, struct fnet *fnet, wchar_t *nickid, struct transferiface *iface, void *data)
{
    struct transfer *transfer;
    
    transfer = newtransfer();
    if(fnet != NULL)
	transfer->fnet = fnet;
    else
	transfer->fnet = fn->fnet;
    transfer->peerid = swcsdup(nickid);
    transfer->state = TRNS_HS;
    transfer->dir = TRNSD_UP;
    if(fn != NULL)
	getfnetnode(transfer->fn = fn);
    transferattach(transfer, iface, data);
    linktransfer(transfer);
    bumptransfer(transfer);
    return(transfer);
}

void linktransfer(struct transfer *transfer)
{
    transfer->next = transfers;
    transfer->prev = NULL;
    if(transfers != NULL)
	transfers->prev = transfer;
    transfers = transfer;
    GCBCHAINDOCB(newtransfercb, transfer);
}

void resettransfer(struct transfer *transfer)
{
    if(transfer->dir == TRNSD_DOWN)
    {
	if(transfer->iface != NULL)
	    transferdetach(transfer);
	killfilter(transfer);
	transfersetstate(transfer, TRNS_WAITING);
	transfersetactivity(transfer, L"reset");
	return;
    }
}

struct transfer *findtransfer(int id)
{
    struct transfer *transfer;
    
    for(transfer = transfers; transfer != NULL; transfer = transfer->next)
    {
	if(transfer->id == id)
	    break;
    }
    return(transfer);
}

static void transexpire(int cancelled, struct transfer *transfer)
{
    transfer->etimer = NULL;
    if(!cancelled)
	bumptransfer(transfer);
    else
	transfer->timeout = 0;
}

static void transferread(struct socket *sk, struct transfer *transfer)
{
    if(sockgetdatalen(sk) >= 65536)
	sk->ignread = 1;
    if((transfer->iface != NULL) && (transfer->iface->gotdata != NULL))
	transfer->iface->gotdata(transfer, transfer->ifacedata);
}

static void transferwrite(struct socket *sk, struct transfer *transfer)
{
    if((transfer->iface != NULL) && (transfer->iface->wantdata != NULL))
	transfer->iface->wantdata(transfer, transfer->ifacedata);
}

static void transfererr(struct socket *sk, int errno, struct transfer *transfer)
{
    if((transfer->iface != NULL) && (transfer->iface->endofdata != NULL))
	transfer->iface->endofdata(transfer, transfer->ifacedata);
}

void transferputdata(struct transfer *transfer, void *buf, size_t size)
{
    time(&transfer->activity);
    sockqueue(transfer->localend, buf, size);
    transfer->curpos += size;
    CBCHAINDOCB(transfer, trans_p, transfer);
}

void transferendofdata(struct transfer *transfer)
{
    if(transfer->curpos >= transfer->size)
    {
	transfersetstate(transfer, TRNS_DONE);
	transfer->localend->readcb = NULL;
	transfer->localend->writecb = NULL;
	transfer->localend->errcb = NULL;
	putsock(transfer->localend);
	transfer->localend = NULL;
    } else {
	resettransfer(transfer);
    }
}

size_t transferdatasize(struct transfer *transfer)
{
    return(sockqueuesize(transfer->localend));
}

void *transfergetdata(struct transfer *transfer, size_t *size)
{
    void *buf;
    
    if(transfer->localend == NULL)
	return(NULL);
    transfer->localend->ignread = 0;
    time(&transfer->activity);
    if((buf = sockgetinbuf(transfer->localend, size)) == NULL)
	return(NULL);
    if((transfer->endpos >= 0) && (transfer->curpos + *size >= transfer->endpos))
    {
	*size = transfer->endpos - transfer->curpos;
	buf = srealloc(buf, *size);
    }
    transfer->curpos += *size;
    CBCHAINDOCB(transfer, trans_p, transfer);
    return(buf);
}

void transferprepul(struct transfer *transfer, size_t size, size_t start, size_t end, struct socket *lesk)
{
    transfersetsize(transfer, size);
    transfer->curpos = start;
    transfer->endpos = end;
    lesk->ignread = 1;
    transfersetlocalend(transfer, lesk);
}

void transferstartul(struct transfer *transfer, struct socket *sk)
{
    transfersetstate(transfer, TRNS_MAIN);
    socksettos(sk, confgetint("transfer", "ultos"));
    if(transfer->localend != NULL)
	transfer->localend->ignread = 0;
}

void transfersetlocalend(struct transfer *transfer, struct socket *sk)
{
    if(transfer->localend != NULL)
	putsock(transfer->localend);
    getsock(transfer->localend = sk);
    sk->data = transfer;
    sk->readcb = (void (*)(struct socket *, void *))transferread;
    sk->writecb = (void (*)(struct socket *, void *))transferwrite;
    sk->errcb = (void (*)(struct socket *, int, void *))transfererr;
}

void bumptransfer(struct transfer *transfer)
{
    struct fnetnode *fn;
    struct fnetpeer *peer;
    time_t now;
    
    if((now = time(NULL)) < transfer->timeout)
    {
	if(transfer->etimer == NULL)
	    transfer->etimer = timercallback(transfer->timeout, (void (*)(int, void *))transexpire, transfer);
	return;
    }
    if(transfer->etimer != NULL)
	canceltimer(transfer->etimer);
    switch(transfer->state)
    {
    case TRNS_WAITING:
	if(transfer->fn != NULL)
	{
	    fn = transfer->fn;
	    if(fn->state != FNN_EST)
	    {
		transfer->close = 1;
		return;
	    }
	    peer = fnetfindpeer(fn, transfer->peerid);
	} else {
	    peer = NULL;
	    for(fn = fnetnodes; fn != NULL; fn = fn->next)
	    {
		if((fn->state == FNN_EST) && (fn->fnet == transfer->fnet) && ((peer = fnetfindpeer(fn, transfer->peerid)) != NULL))
		    break;
	    }
	}
	transfer->etimer = timercallback(transfer->timeout = (time(NULL) + 30), (void (*)(int, void *))transexpire, transfer);
	if(now - transfer->lastreq > 30)
	{
	    if(peer != NULL)
	    {
		fn->fnet->reqconn(peer);
		time(&transfer->lastreq);
	    }
	}
	break;
    case TRNS_HS:
	if(transfer->dir == TRNSD_UP)
	{
	    if(now - transfer->activity < 60)
		transfer->etimer = timercallback(transfer->timeout = (time(NULL) + 60), (void (*)(int, void *))transexpire, transfer);
	    else
		transfer->close = 1;
	} else if(transfer->dir == TRNSD_DOWN) {
	    if(now - transfer->activity < 60)
		transfer->etimer = timercallback(transfer->timeout = (time(NULL) + 60), (void (*)(int, void *))transexpire, transfer);
	    else
		resettransfer(transfer);
	}
	break;
    case TRNS_MAIN:
	if(transfer->dir == TRNSD_UP)
	{
	    if(now - transfer->activity < 300)
		transfer->etimer = timercallback(transfer->timeout = (time(NULL) + 300), (void (*)(int, void *))transexpire, transfer);
	    else
		transfer->close = 1;
	}
	break;
    }
}

void transfersetactivity(struct transfer *transfer, wchar_t *desc)
{
    time(&transfer->activity);
    if(desc != NULL)
    {
	if(transfer->actdesc != NULL)
	    free(transfer->actdesc);
	transfer->actdesc = swcsdup(desc);
    }
    bumptransfer(transfer);
    CBCHAINDOCB(transfer, trans_act, transfer);
}

void transfersetstate(struct transfer *transfer, int newstate)
{
    transfer->state = newstate;
    if(transfer->etimer != NULL)
	canceltimer(transfer->etimer);
    transfersetactivity(transfer, NULL);
    CBCHAINDOCB(transfer, trans_ac, transfer, L"state");
}

void transfersetnick(struct transfer *transfer, wchar_t *newnick)
{
    if(transfer->peernick != NULL)
	free(transfer->peernick);
    transfer->peernick = swcsdup(newnick);
    CBCHAINDOCB(transfer, trans_ac, transfer, L"nick");
}

void transfersetsize(struct transfer *transfer, int newsize)
{
    transfer->size = newsize;
    CBCHAINDOCB(transfer, trans_ac, transfer, L"size");
}

void transferseterror(struct transfer *transfer, int error)
{
    transfer->error = error;
    CBCHAINDOCB(transfer, trans_ac, transfer, L"error");
}

void transfersetpath(struct transfer *transfer, wchar_t *path)
{
    if(transfer->path != NULL)
	free(transfer->path);
    transfer->path = swcsdup(path);
    CBCHAINDOCB(transfer, trans_ac, transfer, L"path");
}

int slotsleft(void)
{
    struct transfer *transfer;
    int slots;
    
    slots = confgetint("transfer", "slots");
    for(transfer = transfers; (transfer != NULL) && (slots > 0); transfer = transfer->next)
    {
	if((transfer->dir == TRNSD_UP) && (transfer->state == TRNS_MAIN) && !transfer->flags.b.minislot)
	    slots--;
    }
    return(slots);
}

static void killfilter(struct transfer *transfer)
{
    if(transfer->filter != -1)
    {
	kill(-transfer->filter, SIGHUP);
	transfer->filter = -1;
    }
    if(transfer->localend)
    {
	transfer->localend->readcb = NULL;
	transfer->localend->writecb = NULL;
	transfer->localend->errcb = NULL;
	putsock(transfer->localend);
	transfer->localend = NULL;
    }
    if(transfer->filterout)
    {
	transfer->filterout->readcb = NULL;
	putsock(transfer->filterout);
	transfer->filterout = NULL;
    }
    if(transfer->filterbuf)
    {
	free(transfer->filterbuf);
	transfer->filterbuf = NULL;
    }
    transfer->filterbufsize = transfer->filterbufdata = 0;
}

static char *findfilter(struct passwd *pwd)
{
    char *path, *filtername;

    if((path = sprintf2("%s/.dcdl-filter", pwd->pw_dir)) != NULL)
    {
	if(!access(path, X_OK))
	    return(path);
	free(path);
    }
    if((filtername = icwcstombs(confgetstr("transfer", "filter"), NULL)) == NULL)
    {
	flog(LOG_WARNING, "could not convert filter name into local charset: %s", strerror(errno));
    } else {
	if(strchr(filtername, '/') == NULL)
	{
	    if((path = sprintf2("/etc/%s", filtername)) != NULL)
	    {
		if(!access(path, X_OK))
		{
		    free(filtername);
		    return(path);
		}
		free(path);
	    }
	    if((path = sprintf2("/usr/etc/%s", filtername)) != NULL)
	    {
		if(!access(path, X_OK))
		{
		    free(filtername);
		    return(path);
		}
		free(path);
	    }
	    if((path = sprintf2("/usr/local/etc/%s", filtername)) != NULL)
	    {
		if(!access(path, X_OK))
		{
		    free(filtername);
		    return(path);
		}
		free(path);
	    }
	} else {
	    if(!access(filtername, X_OK))
		return(filtername);
	}
	free(filtername);
    }
    return(NULL);
}

static void filterread(struct socket *sk, struct transfer *transfer)
{
    char *buf, *p, *p2;
    size_t bufsize;
    wchar_t *cmd, *arg;
    
    if((buf = sockgetinbuf(sk, &bufsize)) == NULL)
	return;
    bufcat(transfer->filterbuf, buf, bufsize);
    free(buf);
    if((p = memchr(transfer->filterbuf, '\n', transfer->filterbufdata)) != NULL)
    {
	*(p++) = 0;
	if((p2 = strchr(transfer->filterbuf, ' ')) != NULL)
	    *(p2++) = 0;
	if((cmd = icmbstowcs(transfer->filterbuf, NULL)) != NULL)
	{
	    arg = NULL;
	    if(p2 != NULL)
	    {
		if((arg = icmbstowcs(p2, NULL)) == NULL)
		    flog(LOG_WARNING, "filter sent a string which could not be converted into the local charset: %s: %s", transfer->filterbuf, strerror(errno));
	    }
	    CBCHAINDOCB(transfer, trans_filterout, transfer, cmd, arg);
	    if(arg != NULL)
		free(arg);
	    free(cmd);
	} else {
	    flog(LOG_WARNING, "filter sent a string which could not be converted into the local charset: %s: %s", transfer->filterbuf, strerror(errno));
	}
	memmove(transfer->filterbuf, p, transfer->filterbufdata -= (p - transfer->filterbuf));
    }
}

static void filterexit(pid_t pid, int status, void *data)
{
    struct transfer *transfer;
    
    for(transfer = transfers; transfer != NULL; transfer = transfer->next)
    {
	if(transfer->filter == pid)
	{
	    transfer->filter = -1;
	    killfilter(transfer);
	    if(WEXITSTATUS(status))
	    {
		resettransfer(transfer);
	    } else {
		freetransfer(transfer);
	    }
	    break;
	}
    }
}

int forkfilter(struct transfer *transfer)
{
    char *filtername, *filename, *peerid, *buf;
    wchar_t *wfilename;
    struct passwd *pwent;
    pid_t pid;
    int inpipe, outpipe;
    char **argv;
    size_t argvsize, argvdata;
    struct socket *insock, *outsock;
    struct transarg *ta;
    char *rec, *val;

    wfilename = transfer->path;
    if(transfer->fnet->filebasename != NULL)
	wfilename = transfer->fnet->filebasename(wfilename);
    if(transfer->auth == NULL)
    {
	flog(LOG_WARNING, "tried to fork filter for transfer with NULL authhandle (tranfer %i)", transfer->id);
	errno = EACCES;
	return(-1);
    }
    if((pwent = getpwuid(transfer->owner)) == NULL)
    {
	flog(LOG_WARNING, "no passwd entry for uid %i (found in transfer %i)", transfer->owner, transfer->id);
	errno = EACCES;
	return(-1);
    }
    if((filtername = findfilter(pwent)) == NULL)
    {
	flog(LOG_WARNING, "could not find filter for user %s", pwent->pw_name);
	errno = ENOENT;
	return(-1);
    }
    if((filename = icwcstombs(wfilename, NULL)) == NULL)
    {
	if((buf = icwcstombs(wfilename, "UTF-8")) == NULL)
	{
	    flog(LOG_WARNING, "could convert transfer filename to neither local charset nor UTF-8: %s", strerror(errno));
	    return(-1);
	}
	filename = sprintf2("utf8-%s", buf);
	free(buf);
    }
    if((peerid = icwcstombs(transfer->peerid, NULL)) == NULL)
    {
	if((buf = icwcstombs(transfer->peerid, "UTF-8")) == NULL)
	{
	    flog(LOG_WARNING, "could convert transfer peerid to neither local charset nor UTF-8: %s", strerror(errno));
	    free(filename);
	    return(-1);
	}
	peerid = sprintf2("utf8-%s", buf);
	free(buf);
    }
    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)
    {
	flog(LOG_WARNING, "could not fork session for filter for transfer %i: %s", transfer->id, strerror(errno));
	return(-1);
    }
    if(pid == 0)
    {
	argv = NULL;
	argvsize = argvdata = 0;
	buf = sprintf2("%i", transfer->size);
	addtobuf(argv, filtername);
	addtobuf(argv, filename);
	addtobuf(argv, buf);
	addtobuf(argv, peerid);
	for(ta = transfer->args; ta != NULL; ta = ta->next)
	{
	    if((rec = icwcstombs(ta->rec, NULL)) == NULL)
		continue;
	    if((val = icwcstombs(ta->val, NULL)) == NULL)
		continue;
	    addtobuf(argv, rec);
	    addtobuf(argv, val);
	}
	addtobuf(argv, NULL);
	execv(filtername, argv);
	flog(LOG_WARNING, "could not exec filter %s: %s", filtername, strerror(errno));
	exit(127);
    }
    insock = wrapsock(inpipe);
    outsock = wrapsock(outpipe);
    /* Really, really strange thing here - sometimes the kernel would
     * return POLLIN on insock, even though it's a write-side
     * pipe. The corresponding read on the pipe naturally returns
     * EBADF, causing doldacond to think there's something wrong with
     * the fd, and thus it closes it. Until I can find out whyever the
     * kernel gives a POLLIN on the fd (if I can at all...), I'll just
     * set ignread on insock for now. */
    insock->ignread = 1;
    transfer->filter = pid;
    transfersetlocalend(transfer, insock);
    getsock(transfer->filterout = outsock);
    outsock->data = transfer;
    outsock->readcb = (void (*)(struct socket *, void *))filterread;
    putsock(insock);
    putsock(outsock);
    free(filtername);
    free(filename);
    free(peerid);
    return(0);
}

static int run(void)
{
    struct transfer *transfer, *next;
    
    for(transfer = transfers; transfer != NULL; transfer = transfer->next)
    {
	if((transfer->endpos >= 0) && (transfer->state == TRNS_MAIN) && (transfer->localend != NULL) && (transfer->localend->state == SOCK_EST) && (transfer->curpos >= transfer->endpos))
	{
	    if((transfer->iface != NULL) && (transfer->iface->endofdata != NULL))
		transfer->iface->endofdata(transfer, transfer->ifacedata);
	    closesock(transfer->localend);
	}
    }
    for(transfer = transfers; transfer != NULL; transfer = next)
    {
	next = transfer->next;
	if(transfer->close)
	{
	    transferdetach(transfer);
	    freetransfer(transfer);
	    continue;
	}
    }
    return(0);
}

static struct configvar myvars[] =
{
    {CONF_VAR_INT, "slots", {.num = 3}},
    {CONF_VAR_INT, "ultos", {.num = SOCK_TOS_MAXTP}},
    {CONF_VAR_INT, "dltos", {.num = SOCK_TOS_MAXTP}},
    {CONF_VAR_STRING, "filter", {.str = L"dc-filter"}},
    {CONF_VAR_END}
};

static struct module me =
{
    .conf =
    {
	.vars = myvars
    },
    .name = "transfer",
    .run = run
};

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