Add trivial HM decoder
[doldaconnect.git] / 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
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);